|
1
|
/**
|
|
2
|
* Copyright (C) 2007 EDIT
|
|
3
|
* European Distributed Institute of Taxonomy
|
|
4
|
* http://www.e-taxonomy.eu
|
|
5
|
*
|
|
6
|
* The contents of this file are subject to the Mozilla Public License Version 1.1
|
|
7
|
* See LICENSE.TXT at the top of this package for the full license terms.
|
|
8
|
*/
|
|
9
|
|
|
10
|
package eu.etaxonomy.cdm.api.service;
|
|
11
|
|
|
12
|
import java.io.IOException;
|
|
13
|
import java.util.ArrayList;
|
|
14
|
import java.util.Collections;
|
|
15
|
import java.util.EnumSet;
|
|
16
|
import java.util.HashMap;
|
|
17
|
import java.util.HashSet;
|
|
18
|
import java.util.Iterator;
|
|
19
|
import java.util.List;
|
|
20
|
import java.util.Map;
|
|
21
|
import java.util.Set;
|
|
22
|
import java.util.UUID;
|
|
23
|
|
|
24
|
import javax.persistence.EntityNotFoundException;
|
|
25
|
|
|
26
|
import org.apache.commons.lang3.StringUtils;
|
|
27
|
import org.apache.log4j.Logger;
|
|
28
|
import org.apache.lucene.queryparser.classic.ParseException;
|
|
29
|
import org.apache.lucene.search.BooleanClause.Occur;
|
|
30
|
import org.apache.lucene.search.BooleanQuery;
|
|
31
|
import org.apache.lucene.search.BooleanQuery.Builder;
|
|
32
|
import org.apache.lucene.search.Query;
|
|
33
|
import org.apache.lucene.search.SortField;
|
|
34
|
import org.apache.lucene.search.grouping.TopGroups;
|
|
35
|
import org.apache.lucene.search.join.ScoreMode;
|
|
36
|
import org.apache.lucene.util.BytesRef;
|
|
37
|
import org.hibernate.criterion.Criterion;
|
|
38
|
import org.springframework.beans.factory.annotation.Autowired;
|
|
39
|
import org.springframework.stereotype.Service;
|
|
40
|
import org.springframework.transaction.annotation.Transactional;
|
|
41
|
|
|
42
|
import eu.etaxonomy.cdm.api.service.config.DeleteConfiguratorBase;
|
|
43
|
import eu.etaxonomy.cdm.api.service.config.IFindTaxaAndNamesConfigurator;
|
|
44
|
import eu.etaxonomy.cdm.api.service.config.IncludedTaxonConfiguration;
|
|
45
|
import eu.etaxonomy.cdm.api.service.config.MatchingTaxonConfigurator;
|
|
46
|
import eu.etaxonomy.cdm.api.service.config.NodeDeletionConfigurator.ChildHandling;
|
|
47
|
import eu.etaxonomy.cdm.api.service.config.SynonymDeletionConfigurator;
|
|
48
|
import eu.etaxonomy.cdm.api.service.config.TaxonDeletionConfigurator;
|
|
49
|
import eu.etaxonomy.cdm.api.service.dto.IdentifiedEntityDTO;
|
|
50
|
import eu.etaxonomy.cdm.api.service.dto.IncludedTaxaDTO;
|
|
51
|
import eu.etaxonomy.cdm.api.service.dto.MarkedEntityDTO;
|
|
52
|
import eu.etaxonomy.cdm.api.service.dto.TaxonRelationshipsDTO;
|
|
53
|
import eu.etaxonomy.cdm.api.service.exception.DataChangeNoRollbackException;
|
|
54
|
import eu.etaxonomy.cdm.api.service.exception.HomotypicalGroupChangeException;
|
|
55
|
import eu.etaxonomy.cdm.api.service.exception.ReferencedObjectUndeletableException;
|
|
56
|
import eu.etaxonomy.cdm.api.service.pager.Pager;
|
|
57
|
import eu.etaxonomy.cdm.api.service.pager.impl.AbstractPagerImpl;
|
|
58
|
import eu.etaxonomy.cdm.api.service.pager.impl.DefaultPagerImpl;
|
|
59
|
import eu.etaxonomy.cdm.api.service.search.ILuceneIndexToolProvider;
|
|
60
|
import eu.etaxonomy.cdm.api.service.search.ISearchResultBuilder;
|
|
61
|
import eu.etaxonomy.cdm.api.service.search.LuceneMultiSearch;
|
|
62
|
import eu.etaxonomy.cdm.api.service.search.LuceneMultiSearchException;
|
|
63
|
import eu.etaxonomy.cdm.api.service.search.LuceneParseException;
|
|
64
|
import eu.etaxonomy.cdm.api.service.search.LuceneSearch;
|
|
65
|
import eu.etaxonomy.cdm.api.service.search.QueryFactory;
|
|
66
|
import eu.etaxonomy.cdm.api.service.search.SearchResult;
|
|
67
|
import eu.etaxonomy.cdm.api.service.search.SearchResultBuilder;
|
|
68
|
import eu.etaxonomy.cdm.api.util.TaxonRelationshipEdge;
|
|
69
|
import eu.etaxonomy.cdm.common.monitor.IProgressMonitor;
|
|
70
|
import eu.etaxonomy.cdm.compare.taxon.HomotypicGroupTaxonComparator;
|
|
71
|
import eu.etaxonomy.cdm.compare.taxon.TaxonComparator;
|
|
72
|
import eu.etaxonomy.cdm.exception.UnpublishedException;
|
|
73
|
import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
|
|
74
|
import eu.etaxonomy.cdm.hibernate.search.AcceptedTaxonBridge;
|
|
75
|
import eu.etaxonomy.cdm.hibernate.search.GroupByTaxonClassBridge;
|
|
76
|
import eu.etaxonomy.cdm.model.CdmBaseType;
|
|
77
|
import eu.etaxonomy.cdm.model.common.Annotation;
|
|
78
|
import eu.etaxonomy.cdm.model.common.AnnotationType;
|
|
79
|
import eu.etaxonomy.cdm.model.common.CdmBase;
|
|
80
|
import eu.etaxonomy.cdm.model.common.IdentifiableEntity;
|
|
81
|
import eu.etaxonomy.cdm.model.common.IdentifiableSource;
|
|
82
|
import eu.etaxonomy.cdm.model.common.Language;
|
|
83
|
import eu.etaxonomy.cdm.model.common.MarkerType;
|
|
84
|
import eu.etaxonomy.cdm.model.common.RelationshipBase.Direction;
|
|
85
|
import eu.etaxonomy.cdm.model.description.CommonTaxonName;
|
|
86
|
import eu.etaxonomy.cdm.model.description.DescriptionBase;
|
|
87
|
import eu.etaxonomy.cdm.model.description.DescriptionElementBase;
|
|
88
|
import eu.etaxonomy.cdm.model.description.DescriptionElementSource;
|
|
89
|
import eu.etaxonomy.cdm.model.description.Distribution;
|
|
90
|
import eu.etaxonomy.cdm.model.description.Feature;
|
|
91
|
import eu.etaxonomy.cdm.model.description.IIdentificationKey;
|
|
92
|
import eu.etaxonomy.cdm.model.description.PolytomousKeyNode;
|
|
93
|
import eu.etaxonomy.cdm.model.description.PresenceAbsenceTerm;
|
|
94
|
import eu.etaxonomy.cdm.model.description.SpecimenDescription;
|
|
95
|
import eu.etaxonomy.cdm.model.description.TaxonDescription;
|
|
96
|
import eu.etaxonomy.cdm.model.description.TaxonInteraction;
|
|
97
|
import eu.etaxonomy.cdm.model.description.TaxonNameDescription;
|
|
98
|
import eu.etaxonomy.cdm.model.location.NamedArea;
|
|
99
|
import eu.etaxonomy.cdm.model.media.Media;
|
|
100
|
import eu.etaxonomy.cdm.model.metadata.SecReferenceHandlingEnum;
|
|
101
|
import eu.etaxonomy.cdm.model.name.HomotypicalGroup;
|
|
102
|
import eu.etaxonomy.cdm.model.name.IZoologicalName;
|
|
103
|
import eu.etaxonomy.cdm.model.name.Rank;
|
|
104
|
import eu.etaxonomy.cdm.model.name.TaxonName;
|
|
105
|
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;
|
|
106
|
import eu.etaxonomy.cdm.model.occurrence.DerivedUnit;
|
|
107
|
import eu.etaxonomy.cdm.model.occurrence.DeterminationEvent;
|
|
108
|
import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;
|
|
109
|
import eu.etaxonomy.cdm.model.reference.OriginalSourceType;
|
|
110
|
import eu.etaxonomy.cdm.model.reference.Reference;
|
|
111
|
import eu.etaxonomy.cdm.model.taxon.Classification;
|
|
112
|
import eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode;
|
|
113
|
import eu.etaxonomy.cdm.model.taxon.SecundumSource;
|
|
114
|
import eu.etaxonomy.cdm.model.taxon.Synonym;
|
|
115
|
import eu.etaxonomy.cdm.model.taxon.SynonymType;
|
|
116
|
import eu.etaxonomy.cdm.model.taxon.Taxon;
|
|
117
|
import eu.etaxonomy.cdm.model.taxon.TaxonBase;
|
|
118
|
import eu.etaxonomy.cdm.model.taxon.TaxonNode;
|
|
119
|
import eu.etaxonomy.cdm.model.taxon.TaxonRelationship;
|
|
120
|
import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;
|
|
121
|
import eu.etaxonomy.cdm.model.term.DefinedTerm;
|
|
122
|
import eu.etaxonomy.cdm.persistence.dao.common.Restriction;
|
|
123
|
import eu.etaxonomy.cdm.persistence.dao.initializer.AbstractBeanInitializer;
|
|
124
|
import eu.etaxonomy.cdm.persistence.dao.name.ITaxonNameDao;
|
|
125
|
import eu.etaxonomy.cdm.persistence.dao.occurrence.IOccurrenceDao;
|
|
126
|
import eu.etaxonomy.cdm.persistence.dao.taxon.IClassificationDao;
|
|
127
|
import eu.etaxonomy.cdm.persistence.dao.taxon.ITaxonDao;
|
|
128
|
import eu.etaxonomy.cdm.persistence.dao.taxon.ITaxonNodeDao;
|
|
129
|
import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
|
|
130
|
import eu.etaxonomy.cdm.persistence.query.MatchMode;
|
|
131
|
import eu.etaxonomy.cdm.persistence.query.OrderHint;
|
|
132
|
import eu.etaxonomy.cdm.persistence.query.OrderHint.SortOrder;
|
|
133
|
import eu.etaxonomy.cdm.persistence.query.TaxonTitleType;
|
|
134
|
import eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy;
|
|
135
|
|
|
136
|
|
|
137
|
/**
|
|
138
|
* @author a.kohlbecker
|
|
139
|
* @since 10.09.2010
|
|
140
|
*/
|
|
141
|
@Service
|
|
142
|
@Transactional(readOnly = true)
|
|
143
|
public class TaxonServiceImpl
|
|
144
|
extends IdentifiableServiceBase<TaxonBase,ITaxonDao>
|
|
145
|
implements ITaxonService{
|
|
146
|
|
|
147
|
private static final Logger logger = Logger.getLogger(TaxonServiceImpl.class);
|
|
148
|
|
|
149
|
public static final String POTENTIAL_COMBINATION_NAMESPACE = "Potential combination";
|
|
150
|
|
|
151
|
public static final String INFERRED_EPITHET_NAMESPACE = "Inferred epithet";
|
|
152
|
|
|
153
|
public static final String INFERRED_GENUS_NAMESPACE = "Inferred genus";
|
|
154
|
|
|
155
|
@Autowired
|
|
156
|
private ITaxonNodeDao taxonNodeDao;
|
|
157
|
|
|
158
|
@Autowired
|
|
159
|
private ITaxonNameDao nameDao;
|
|
160
|
|
|
161
|
@Autowired
|
|
162
|
private INameService nameService;
|
|
163
|
|
|
164
|
@Autowired
|
|
165
|
private IOccurrenceService occurrenceService;
|
|
166
|
|
|
167
|
@Autowired
|
|
168
|
private ITaxonNodeService nodeService;
|
|
169
|
|
|
170
|
@Autowired
|
|
171
|
private IDescriptionService descriptionService;
|
|
172
|
|
|
173
|
@Autowired
|
|
174
|
private IReferenceService referenceService;
|
|
175
|
//
|
|
176
|
// @Autowired
|
|
177
|
// private IOrderedTermVocabularyDao orderedVocabularyDao;
|
|
178
|
|
|
179
|
@Autowired
|
|
180
|
private IOccurrenceDao occurrenceDao;
|
|
181
|
|
|
182
|
@Autowired
|
|
183
|
private IClassificationDao classificationDao;
|
|
184
|
|
|
185
|
@Autowired
|
|
186
|
private AbstractBeanInitializer beanInitializer;
|
|
187
|
|
|
188
|
@Autowired
|
|
189
|
private ILuceneIndexToolProvider luceneIndexToolProvider;
|
|
190
|
|
|
191
|
//************************ CONSTRUCTOR ****************************/
|
|
192
|
public TaxonServiceImpl(){
|
|
193
|
if (logger.isDebugEnabled()) { logger.debug("Load TaxonService Bean"); }
|
|
194
|
}
|
|
195
|
|
|
196
|
// ****************************** METHODS ********************************/
|
|
197
|
|
|
198
|
@Override
|
|
199
|
public TaxonBase load(UUID uuid, boolean includeUnpublished, List<String> propertyPaths) {
|
|
200
|
return dao.load(uuid, includeUnpublished, propertyPaths);
|
|
201
|
}
|
|
202
|
|
|
203
|
@Override
|
|
204
|
public List<TaxonBase> searchByName(String name, boolean includeUnpublished, Reference sec) {
|
|
205
|
return dao.getTaxaByName(name, includeUnpublished, sec);
|
|
206
|
}
|
|
207
|
|
|
208
|
@Override
|
|
209
|
@Transactional(readOnly = false)
|
|
210
|
public UpdateResult swapSynonymAndAcceptedTaxon(Synonym synonym, Taxon acceptedTaxon, boolean setNameInSource, boolean newUuidForAcceptedTaxon){
|
|
211
|
if (newUuidForAcceptedTaxon){
|
|
212
|
return swapSynonymAndAcceptedTaxonNewUuid(synonym, acceptedTaxon, setNameInSource);
|
|
213
|
}else{
|
|
214
|
return swapSynonymAndAcceptedTaxon(synonym, acceptedTaxon, setNameInSource);
|
|
215
|
}
|
|
216
|
}
|
|
217
|
|
|
218
|
private UpdateResult swapSynonymAndAcceptedTaxon(Synonym synonym, Taxon acceptedTaxon, boolean setNameInSource){
|
|
219
|
UpdateResult result = new UpdateResult();
|
|
220
|
String oldTaxonTitleCache = acceptedTaxon.getTitleCache();
|
|
221
|
|
|
222
|
TaxonName synonymName = synonym.getName();
|
|
223
|
TaxonName taxonName = HibernateProxyHelper.deproxy(acceptedTaxon.getName());
|
|
224
|
|
|
225
|
acceptedTaxon.setName(synonymName);
|
|
226
|
synonym.setName(taxonName);
|
|
227
|
|
|
228
|
//nameUsedInSource
|
|
229
|
handleNameUsedInSourceForSwap(setNameInSource, taxonName, oldTaxonTitleCache, acceptedTaxon.getDescriptions());
|
|
230
|
|
|
231
|
saveOrUpdate(acceptedTaxon);
|
|
232
|
saveOrUpdate(synonym);
|
|
233
|
result.setCdmEntity(acceptedTaxon);
|
|
234
|
result.addUpdatedObject(synonym);
|
|
235
|
|
|
236
|
return result;
|
|
237
|
}
|
|
238
|
|
|
239
|
private UpdateResult swapSynonymAndAcceptedTaxonNewUuid(Synonym synonym, Taxon acceptedTaxon, boolean setNameInSource){
|
|
240
|
UpdateResult result = new UpdateResult();
|
|
241
|
acceptedTaxon.removeSynonym(synonym);
|
|
242
|
TaxonName synonymName = synonym.getName();
|
|
243
|
TaxonName taxonName = HibernateProxyHelper.deproxy(acceptedTaxon.getName());
|
|
244
|
String oldTaxonTitleCache = acceptedTaxon.getTitleCache();
|
|
245
|
|
|
246
|
boolean sameHomotypicGroup = synonymName.getHomotypicalGroup().equals(taxonName.getHomotypicalGroup());
|
|
247
|
synonymName.removeTaxonBase(synonym);
|
|
248
|
|
|
249
|
List<Synonym> synonyms = new ArrayList<>();
|
|
250
|
for (Synonym syn: acceptedTaxon.getSynonyms()){
|
|
251
|
syn = HibernateProxyHelper.deproxy(syn, Synonym.class);
|
|
252
|
synonyms.add(syn);
|
|
253
|
}
|
|
254
|
for (Synonym syn: synonyms){
|
|
255
|
acceptedTaxon.removeSynonym(syn);
|
|
256
|
}
|
|
257
|
Taxon newTaxon = acceptedTaxon.clone(true, true, false, true);
|
|
258
|
|
|
259
|
//move descriptions
|
|
260
|
Set<TaxonDescription> descriptionsToCopy = new HashSet<>(acceptedTaxon.getDescriptions());
|
|
261
|
for (TaxonDescription description: descriptionsToCopy){
|
|
262
|
newTaxon.addDescription(description);
|
|
263
|
}
|
|
264
|
//nameUsedInSource
|
|
265
|
handleNameUsedInSourceForSwap(setNameInSource, taxonName, oldTaxonTitleCache, newTaxon.getDescriptions());
|
|
266
|
|
|
267
|
newTaxon.setName(synonymName);
|
|
268
|
|
|
269
|
newTaxon.setPublish(synonym.isPublish());
|
|
270
|
for (Synonym syn: synonyms){
|
|
271
|
if (!syn.getName().equals(newTaxon.getName())){
|
|
272
|
newTaxon.addSynonym(syn, syn.getType());
|
|
273
|
}
|
|
274
|
}
|
|
275
|
|
|
276
|
//move all data to new taxon
|
|
277
|
//Move Taxon RelationShips to new Taxon
|
|
278
|
for(TaxonRelationship taxonRelationship : newTaxon.getTaxonRelations()){
|
|
279
|
newTaxon.removeTaxonRelation(taxonRelationship);
|
|
280
|
}
|
|
281
|
|
|
282
|
for(TaxonRelationship taxonRelationship : acceptedTaxon.getTaxonRelations()){
|
|
283
|
Taxon fromTaxon = HibernateProxyHelper.deproxy(taxonRelationship.getFromTaxon());
|
|
284
|
Taxon toTaxon = HibernateProxyHelper.deproxy(taxonRelationship.getToTaxon());
|
|
285
|
if (fromTaxon == acceptedTaxon){
|
|
286
|
newTaxon.addTaxonRelation(taxonRelationship.getToTaxon(), taxonRelationship.getType(),
|
|
287
|
taxonRelationship.getCitation(), taxonRelationship.getCitationMicroReference());
|
|
288
|
|
|
289
|
}else if(toTaxon == acceptedTaxon){
|
|
290
|
fromTaxon.addTaxonRelation(newTaxon, taxonRelationship.getType(),
|
|
291
|
taxonRelationship.getCitation(), taxonRelationship.getCitationMicroReference());
|
|
292
|
saveOrUpdate(fromTaxon);
|
|
293
|
|
|
294
|
}else{
|
|
295
|
logger.warn("Taxon is not part of its own Taxonrelationship");
|
|
296
|
}
|
|
297
|
|
|
298
|
// Remove old relationships
|
|
299
|
fromTaxon.removeTaxonRelation(taxonRelationship);
|
|
300
|
toTaxon.removeTaxonRelation(taxonRelationship);
|
|
301
|
taxonRelationship.setToTaxon(null);
|
|
302
|
taxonRelationship.setFromTaxon(null);
|
|
303
|
}
|
|
304
|
|
|
305
|
//taxon nodes
|
|
306
|
List<TaxonNode> nodes = new ArrayList<>(acceptedTaxon.getTaxonNodes());
|
|
307
|
for (TaxonNode node: nodes){
|
|
308
|
node = HibernateProxyHelper.deproxy(node);
|
|
309
|
TaxonNode parent = node.getParent();
|
|
310
|
acceptedTaxon.removeTaxonNode(node);
|
|
311
|
node.setTaxon(newTaxon);
|
|
312
|
if (parent != null){
|
|
313
|
parent.addChildNode(node, null, null);
|
|
314
|
}
|
|
315
|
}
|
|
316
|
|
|
317
|
//synonym
|
|
318
|
Synonym newSynonym = synonym.clone();
|
|
319
|
newSynonym.setName(taxonName);
|
|
320
|
newSynonym.setPublish(acceptedTaxon.isPublish());
|
|
321
|
if (sameHomotypicGroup){
|
|
322
|
newTaxon.addSynonym(newSynonym, SynonymType.HOMOTYPIC_SYNONYM_OF());
|
|
323
|
}else{
|
|
324
|
newTaxon.addSynonym(newSynonym, SynonymType.HETEROTYPIC_SYNONYM_OF());
|
|
325
|
}
|
|
326
|
|
|
327
|
//deletes
|
|
328
|
TaxonDeletionConfigurator conf = new TaxonDeletionConfigurator();
|
|
329
|
conf.setDeleteNameIfPossible(false);
|
|
330
|
SynonymDeletionConfigurator confSyn = new SynonymDeletionConfigurator();
|
|
331
|
confSyn.setDeleteNameIfPossible(false);
|
|
332
|
result.setCdmEntity(newTaxon);
|
|
333
|
|
|
334
|
DeleteResult deleteResult = deleteTaxon(acceptedTaxon.getUuid(), conf, null);
|
|
335
|
if (synonym.isPersited()){
|
|
336
|
synonym.setSecSource(null);
|
|
337
|
deleteResult.includeResult(deleteSynonym(synonym.getUuid(), confSyn));
|
|
338
|
}
|
|
339
|
result.includeResult(deleteResult);
|
|
340
|
|
|
341
|
return result;
|
|
342
|
}
|
|
343
|
|
|
344
|
private void handleNameUsedInSourceForSwap(boolean setNameInSource, TaxonName taxonName, String oldTaxonTitleCache,
|
|
345
|
Set<TaxonDescription> descriptions) {
|
|
346
|
for(TaxonDescription description : descriptions){
|
|
347
|
String message = "Description copied from former accepted taxon: %s (Old title: %s)";
|
|
348
|
message = String.format(message, oldTaxonTitleCache, description.getTitleCache());
|
|
349
|
description.setTitleCache(message, true);
|
|
350
|
if(setNameInSource){
|
|
351
|
for (DescriptionElementBase element: description.getElements()){
|
|
352
|
for (DescriptionElementSource source: element.getSources()){
|
|
353
|
if (source.getNameUsedInSource() == null){
|
|
354
|
source.setNameUsedInSource(taxonName);
|
|
355
|
}
|
|
356
|
}
|
|
357
|
}
|
|
358
|
}
|
|
359
|
}
|
|
360
|
}
|
|
361
|
|
|
362
|
@Override
|
|
363
|
@Transactional(readOnly = false)
|
|
364
|
public UpdateResult changeSynonymToAcceptedTaxon(Synonym synonym, Taxon acceptedTaxon, Reference newSecRef, String microRef, SecReferenceHandlingEnum secHandling, boolean deleteSynonym) {
|
|
365
|
UpdateResult result = new UpdateResult();
|
|
366
|
TaxonName acceptedName = acceptedTaxon.getName();
|
|
367
|
TaxonName synonymName = synonym.getName();
|
|
368
|
HomotypicalGroup synonymHomotypicGroup = synonymName.getHomotypicalGroup();
|
|
369
|
|
|
370
|
//check synonym is not homotypic
|
|
371
|
if (acceptedName.getHomotypicalGroup().equals(synonymHomotypicGroup)){
|
|
372
|
String message = "The accepted taxon and the synonym are part of the same homotypical group and therefore can not be both accepted.";
|
|
373
|
result.addException(new HomotypicalGroupChangeException(message));
|
|
374
|
result.setAbort();
|
|
375
|
return result;
|
|
376
|
}
|
|
377
|
if (secHandling != null && secHandling.equals(SecReferenceHandlingEnum.KeepAlways)){
|
|
378
|
newSecRef = synonym.getSec();
|
|
379
|
}
|
|
380
|
Taxon newAcceptedTaxon = Taxon.NewInstance(synonymName, newSecRef, microRef);
|
|
381
|
newAcceptedTaxon.setPublish(synonym.isPublish());
|
|
382
|
dao.save(newAcceptedTaxon);
|
|
383
|
result.setCdmEntity(newAcceptedTaxon);
|
|
384
|
SynonymType relTypeForGroup = SynonymType.HOMOTYPIC_SYNONYM_OF();
|
|
385
|
List<Synonym> heteroSynonyms = acceptedTaxon.getSynonymsInGroup(synonymHomotypicGroup);
|
|
386
|
|
|
387
|
for (Synonym heteroSynonym : heteroSynonyms){
|
|
388
|
if (secHandling == null || !secHandling.equals(SecReferenceHandlingEnum.KeepAlways)){
|
|
389
|
heteroSynonym.setSec(newSecRef);
|
|
390
|
}
|
|
391
|
if (synonym.equals(heteroSynonym)){
|
|
392
|
acceptedTaxon.removeSynonym(heteroSynonym, false);
|
|
393
|
}else{
|
|
394
|
//move synonyms in same homotypic group to new accepted taxon
|
|
395
|
newAcceptedTaxon.addSynonym(heteroSynonym, relTypeForGroup);
|
|
396
|
}
|
|
397
|
}
|
|
398
|
dao.saveOrUpdate(acceptedTaxon);
|
|
399
|
result.addUpdatedObject(acceptedTaxon);
|
|
400
|
if (deleteSynonym){
|
|
401
|
|
|
402
|
try {
|
|
403
|
this.dao.flush();
|
|
404
|
SynonymDeletionConfigurator config = new SynonymDeletionConfigurator();
|
|
405
|
config.setDeleteNameIfPossible(false);
|
|
406
|
this.deleteSynonym(synonym, config);
|
|
407
|
|
|
408
|
} catch (Exception e) {
|
|
409
|
result.addException(e);
|
|
410
|
}
|
|
411
|
}
|
|
412
|
|
|
413
|
return result;
|
|
414
|
}
|
|
415
|
|
|
416
|
@Override
|
|
417
|
@Transactional(readOnly = false)
|
|
418
|
public UpdateResult changeSynonymToAcceptedTaxon(UUID synonymUuid,
|
|
419
|
UUID acceptedTaxonUuid,
|
|
420
|
UUID newParentNodeUuid,
|
|
421
|
UUID newSec,
|
|
422
|
String microReference,
|
|
423
|
SecReferenceHandlingEnum secHandling,
|
|
424
|
boolean deleteSynonym) {
|
|
425
|
UpdateResult result = new UpdateResult();
|
|
426
|
Synonym synonym = CdmBase.deproxy(dao.load(synonymUuid), Synonym.class);
|
|
427
|
Taxon acceptedTaxon = CdmBase.deproxy(dao.load(acceptedTaxonUuid), Taxon.class);
|
|
428
|
TaxonNode newParentNode = taxonNodeDao.load(newParentNodeUuid);
|
|
429
|
Reference newSecRef = null;
|
|
430
|
switch (secHandling){
|
|
431
|
case AlwaysDelete:
|
|
432
|
newSecRef = null;
|
|
433
|
break;
|
|
434
|
case KeepAlways:
|
|
435
|
break;
|
|
436
|
case UseNewParentSec:
|
|
437
|
newSecRef = newParentNode.getTaxon() != null? newParentNode.getTaxon().getSec(): null;
|
|
438
|
break;
|
|
439
|
case KeepWhenSame:
|
|
440
|
Reference parentSec = newParentNode.getTaxon() != null? newParentNode.getTaxon().getSec(): null;
|
|
441
|
Reference synSec = synonym.getSec();
|
|
442
|
if (parentSec != null && synSec != null && parentSec.equals(synSec)){
|
|
443
|
newSecRef = synonym.getSec();
|
|
444
|
}else{
|
|
445
|
newSecRef = CdmBase.deproxy(referenceService.load(newSec));
|
|
446
|
}
|
|
447
|
break;
|
|
448
|
case WarningSelect:
|
|
449
|
newSecRef = CdmBase.deproxy(referenceService.load(newSec));
|
|
450
|
break;
|
|
451
|
default:
|
|
452
|
break;
|
|
453
|
}
|
|
454
|
|
|
455
|
result = changeSynonymToAcceptedTaxon(synonym, acceptedTaxon, newSecRef, microReference, secHandling, deleteSynonym);
|
|
456
|
Taxon newTaxon = (Taxon)result.getCdmEntity();
|
|
457
|
|
|
458
|
TaxonNode newNode = newParentNode.addChildTaxon(newTaxon, null, null);
|
|
459
|
taxonNodeDao.save(newNode);
|
|
460
|
result.addUpdatedObject(newTaxon);
|
|
461
|
result.addUpdatedObject(acceptedTaxon);
|
|
462
|
result.setCdmEntity(newNode);
|
|
463
|
return result;
|
|
464
|
}
|
|
465
|
|
|
466
|
@Override
|
|
467
|
@Transactional(readOnly = false)
|
|
468
|
public UpdateResult changeSynonymToRelatedTaxon(UUID synonymUuid,
|
|
469
|
UUID toTaxonUuid,
|
|
470
|
TaxonRelationshipType taxonRelationshipType,
|
|
471
|
Reference citation,
|
|
472
|
String microcitation){
|
|
473
|
|
|
474
|
UpdateResult result = new UpdateResult();
|
|
475
|
Taxon toTaxon = (Taxon) dao.load(toTaxonUuid);
|
|
476
|
Synonym synonym = (Synonym) dao.load(synonymUuid);
|
|
477
|
result = changeSynonymToRelatedTaxon(synonym, toTaxon, taxonRelationshipType, citation, microcitation);
|
|
478
|
Taxon relatedTaxon = (Taxon)result.getCdmEntity();
|
|
479
|
// result.setCdmEntity(relatedTaxon);
|
|
480
|
result.addUpdatedObject(relatedTaxon);
|
|
481
|
result.addUpdatedObject(toTaxon);
|
|
482
|
return result;
|
|
483
|
}
|
|
484
|
|
|
485
|
@Override
|
|
486
|
@Transactional(readOnly = false)
|
|
487
|
public UpdateResult changeSynonymToRelatedTaxon(Synonym synonym, Taxon toTaxon, TaxonRelationshipType taxonRelationshipType, Reference citation, String microcitation){
|
|
488
|
// Get name from synonym
|
|
489
|
if (synonym == null){
|
|
490
|
return null;
|
|
491
|
}
|
|
492
|
|
|
493
|
UpdateResult result = new UpdateResult();
|
|
494
|
|
|
495
|
TaxonName synonymName = synonym.getName();
|
|
496
|
|
|
497
|
/* // remove synonym from taxon
|
|
498
|
toTaxon.removeSynonym(synonym);
|
|
499
|
*/
|
|
500
|
// Create a taxon with synonym name
|
|
501
|
Taxon fromTaxon = Taxon.NewInstance(synonymName, null);
|
|
502
|
fromTaxon.setPublish(synonym.isPublish());
|
|
503
|
save(fromTaxon);
|
|
504
|
fromTaxon.setAppendedPhrase(synonym.getAppendedPhrase());
|
|
505
|
|
|
506
|
// Add taxon relation
|
|
507
|
fromTaxon.addTaxonRelation(toTaxon, taxonRelationshipType, citation, microcitation);
|
|
508
|
result.setCdmEntity(fromTaxon);
|
|
509
|
// since we are swapping names, we have to detach the name from the synonym completely.
|
|
510
|
// Otherwise the synonym will still be in the list of typified names.
|
|
511
|
// synonym.getName().removeTaxonBase(synonym);
|
|
512
|
result.includeResult(this.deleteSynonym(synonym, null));
|
|
513
|
|
|
514
|
return result;
|
|
515
|
}
|
|
516
|
|
|
517
|
@Transactional(readOnly = false)
|
|
518
|
@Override
|
|
519
|
public void changeHomotypicalGroupOfSynonym(Synonym synonym, HomotypicalGroup newHomotypicalGroup,
|
|
520
|
Taxon targetTaxon, boolean setBasionymRelationIfApplicable){
|
|
521
|
// Get synonym name
|
|
522
|
TaxonName synonymName = synonym.getName();
|
|
523
|
HomotypicalGroup oldHomotypicalGroup = synonymName.getHomotypicalGroup();
|
|
524
|
|
|
525
|
// Switch groups
|
|
526
|
oldHomotypicalGroup.removeTypifiedName(synonymName, false);
|
|
527
|
newHomotypicalGroup.addTypifiedName(synonymName);
|
|
528
|
|
|
529
|
//remove existing basionym relationships
|
|
530
|
synonymName.removeBasionyms();
|
|
531
|
|
|
532
|
//add basionym relationship
|
|
533
|
if (setBasionymRelationIfApplicable){
|
|
534
|
Set<TaxonName> basionyms = newHomotypicalGroup.getBasionyms();
|
|
535
|
for (TaxonName basionym : basionyms){
|
|
536
|
synonymName.addBasionym(basionym);
|
|
537
|
}
|
|
538
|
}
|
|
539
|
|
|
540
|
//set synonym relationship correctly
|
|
541
|
Taxon acceptedTaxon = synonym.getAcceptedTaxon();
|
|
542
|
|
|
543
|
boolean hasNewTargetTaxon = targetTaxon != null && !targetTaxon.equals(acceptedTaxon);
|
|
544
|
if (acceptedTaxon != null){
|
|
545
|
|
|
546
|
HomotypicalGroup acceptedGroup = acceptedTaxon.getHomotypicGroup();
|
|
547
|
boolean isHomotypicToTaxon = acceptedGroup.equals(newHomotypicalGroup);
|
|
548
|
SynonymType newRelationType = isHomotypicToTaxon? SynonymType.HOMOTYPIC_SYNONYM_OF() : SynonymType.HETEROTYPIC_SYNONYM_OF();
|
|
549
|
synonym.setType(newRelationType);
|
|
550
|
|
|
551
|
if (hasNewTargetTaxon){
|
|
552
|
acceptedTaxon.removeSynonym(synonym, false);
|
|
553
|
}
|
|
554
|
}
|
|
555
|
if (hasNewTargetTaxon ){
|
|
556
|
@SuppressWarnings("null")
|
|
557
|
HomotypicalGroup acceptedGroup = targetTaxon.getHomotypicGroup();
|
|
558
|
boolean isHomotypicToTaxon = acceptedGroup.equals(newHomotypicalGroup);
|
|
559
|
SynonymType relType = isHomotypicToTaxon? SynonymType.HOMOTYPIC_SYNONYM_OF() : SynonymType.HETEROTYPIC_SYNONYM_OF();
|
|
560
|
targetTaxon.addSynonym(synonym, relType);
|
|
561
|
}
|
|
562
|
}
|
|
563
|
|
|
564
|
@Override
|
|
565
|
@Transactional(readOnly = false)
|
|
566
|
public UpdateResult updateCaches(Class<? extends TaxonBase> clazz, Integer stepSize, IIdentifiableEntityCacheStrategy<TaxonBase> cacheStrategy, IProgressMonitor monitor) {
|
|
567
|
if (clazz == null){
|
|
568
|
clazz = TaxonBase.class;
|
|
569
|
}
|
|
570
|
return super.updateCachesImpl(clazz, stepSize, cacheStrategy, monitor);
|
|
571
|
}
|
|
572
|
|
|
573
|
@Override
|
|
574
|
@Autowired
|
|
575
|
protected void setDao(ITaxonDao dao) {
|
|
576
|
this.dao = dao;
|
|
577
|
}
|
|
578
|
|
|
579
|
@Override
|
|
580
|
public <T extends TaxonBase> Pager<T> findTaxaByName(Class<T> clazz, String uninomial, String infragenericEpithet, String specificEpithet,
|
|
581
|
String infraspecificEpithet, String authorshipCache, Rank rank, Integer pageSize,Integer pageNumber, List<String> propertyPaths) {
|
|
582
|
long numberOfResults = dao.countTaxaByName(clazz, uninomial, infragenericEpithet, specificEpithet, infraspecificEpithet, authorshipCache, rank);
|
|
583
|
|
|
584
|
List<T> results = new ArrayList<>();
|
|
585
|
if(numberOfResults > 0) { // no point checking again
|
|
586
|
results = dao.findTaxaByName(clazz, uninomial, infragenericEpithet, specificEpithet, infraspecificEpithet, authorshipCache, rank,
|
|
587
|
pageSize, pageNumber, propertyPaths);
|
|
588
|
}
|
|
589
|
|
|
590
|
return new DefaultPagerImpl<>(pageNumber, numberOfResults, pageSize, results);
|
|
591
|
}
|
|
592
|
|
|
593
|
@Override
|
|
594
|
public <T extends TaxonBase> List<T> listTaxaByName(Class<T> clazz, String uninomial, String infragenericEpithet, String specificEpithet,
|
|
595
|
String infraspecificEpithet, String authorshipCache, Rank rank, Integer pageSize,Integer pageNumber, List<String> propertyPaths) {
|
|
596
|
|
|
597
|
return findTaxaByName(clazz, uninomial, infragenericEpithet, specificEpithet, infragenericEpithet, authorshipCache, rank,
|
|
598
|
pageSize, pageNumber, propertyPaths).getRecords();
|
|
599
|
}
|
|
600
|
|
|
601
|
@Override
|
|
602
|
public List<TaxonRelationship> listToTaxonRelationships(Taxon taxon, TaxonRelationshipType type,
|
|
603
|
boolean includeUnpublished, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths){
|
|
604
|
long numberOfResults = dao.countTaxonRelationships(taxon, type, includeUnpublished, TaxonRelationship.Direction.relatedTo);
|
|
605
|
|
|
606
|
List<TaxonRelationship> results = new ArrayList<>();
|
|
607
|
if(numberOfResults > 0) { // no point checking again
|
|
608
|
results = dao.getTaxonRelationships(taxon, type, includeUnpublished, pageSize, pageNumber, orderHints, propertyPaths, TaxonRelationship.Direction.relatedTo);
|
|
609
|
}
|
|
610
|
return results;
|
|
611
|
}
|
|
612
|
|
|
613
|
@Override
|
|
614
|
public Pager<TaxonRelationship> pageToTaxonRelationships(Taxon taxon, TaxonRelationshipType type,
|
|
615
|
boolean includeUnpublished, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
|
|
616
|
long numberOfResults = dao.countTaxonRelationships(taxon, type, includeUnpublished, TaxonRelationship.Direction.relatedTo);
|
|
617
|
|
|
618
|
List<TaxonRelationship> results = new ArrayList<>();
|
|
619
|
if(numberOfResults > 0) { // no point checking again
|
|
620
|
results = dao.getTaxonRelationships(taxon, type, includeUnpublished, pageSize, pageNumber, orderHints, propertyPaths, TaxonRelationship.Direction.relatedTo);
|
|
621
|
}
|
|
622
|
return new DefaultPagerImpl<>(pageNumber, numberOfResults, pageSize, results);
|
|
623
|
}
|
|
624
|
|
|
625
|
@Override
|
|
626
|
public List<TaxonRelationship> listFromTaxonRelationships(Taxon taxon, TaxonRelationshipType type,
|
|
627
|
boolean includeUnpublished, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths){
|
|
628
|
long numberOfResults = dao.countTaxonRelationships(taxon, type, includeUnpublished, TaxonRelationship.Direction.relatedFrom);
|
|
629
|
|
|
630
|
List<TaxonRelationship> results = new ArrayList<>();
|
|
631
|
if(numberOfResults > 0) { // no point checking again
|
|
632
|
results = dao.getTaxonRelationships(taxon, type, includeUnpublished, pageSize, pageNumber, orderHints, propertyPaths, TaxonRelationship.Direction.relatedFrom);
|
|
633
|
}
|
|
634
|
return results;
|
|
635
|
}
|
|
636
|
|
|
637
|
@Override
|
|
638
|
public Pager<TaxonRelationship> pageFromTaxonRelationships(Taxon taxon, TaxonRelationshipType type,
|
|
639
|
boolean includeUnpublished, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
|
|
640
|
long numberOfResults = dao.countTaxonRelationships(taxon, type, includeUnpublished, TaxonRelationship.Direction.relatedFrom);
|
|
641
|
|
|
642
|
List<TaxonRelationship> results = new ArrayList<>();
|
|
643
|
if(numberOfResults > 0) { // no point checking again
|
|
644
|
results = dao.getTaxonRelationships(taxon, type, includeUnpublished, pageSize, pageNumber, orderHints, propertyPaths, TaxonRelationship.Direction.relatedFrom);
|
|
645
|
}
|
|
646
|
return new DefaultPagerImpl<>(pageNumber, numberOfResults, pageSize, results);
|
|
647
|
}
|
|
648
|
|
|
649
|
@Override
|
|
650
|
public List<TaxonRelationship> listTaxonRelationships(Set<TaxonRelationshipType> types,
|
|
651
|
Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
|
|
652
|
|
|
653
|
Long numberOfResults = dao.countTaxonRelationships(types);
|
|
654
|
List<TaxonRelationship> results = new ArrayList<>();
|
|
655
|
if(numberOfResults > 0) {
|
|
656
|
results = dao.getTaxonRelationships(types, pageSize, pageNumber, orderHints, propertyPaths);
|
|
657
|
}
|
|
658
|
return results;
|
|
659
|
}
|
|
660
|
|
|
661
|
@Override
|
|
662
|
public <S extends TaxonBase> Pager<S> page(Class<S> clazz, List<Restriction<?>> restrictions, Integer pageSize,
|
|
663
|
Integer pageIndex, List<OrderHint> orderHints, List<String> propertyPaths) {
|
|
664
|
return page(clazz, restrictions, pageSize, pageIndex, orderHints, propertyPaths, INCLUDE_UNPUBLISHED);
|
|
665
|
}
|
|
666
|
|
|
667
|
@Override
|
|
668
|
public <S extends TaxonBase> Pager<S> page(Class<S> clazz, List<Restriction<?>> restrictions, Integer pageSize,
|
|
669
|
Integer pageIndex, List<OrderHint> orderHints, List<String> propertyPaths, boolean includeUnpublished) {
|
|
670
|
|
|
671
|
List<S> records;
|
|
672
|
long resultSize = dao.count(clazz, restrictions);
|
|
673
|
if(AbstractPagerImpl.hasResultsInRange(resultSize, pageIndex, pageSize)){
|
|
674
|
records = dao.list(clazz, restrictions, pageSize, pageIndex, orderHints, propertyPaths, includeUnpublished);
|
|
675
|
} else {
|
|
676
|
records = new ArrayList<>();
|
|
677
|
}
|
|
678
|
Pager<S> pager = new DefaultPagerImpl<>(pageIndex, resultSize, pageSize, records);
|
|
679
|
return pager;
|
|
680
|
}
|
|
681
|
|
|
682
|
@Override
|
|
683
|
public Taxon findAcceptedTaxonFor(UUID synonymUuid, UUID classificationUuid,
|
|
684
|
boolean includeUnpublished, List<String> propertyPaths) throws UnpublishedException{
|
|
685
|
|
|
686
|
Synonym synonym = null;
|
|
687
|
|
|
688
|
try {
|
|
689
|
synonym = (Synonym) dao.load(synonymUuid);
|
|
690
|
checkPublished(synonym, includeUnpublished, "Synoym is unpublished.");
|
|
691
|
} catch (ClassCastException e){
|
|
692
|
throw new EntityNotFoundException("The TaxonBase entity referenced by " + synonymUuid + " is not a Synonmy");
|
|
693
|
} catch (NullPointerException e){
|
|
694
|
throw new EntityNotFoundException("No TaxonBase entity found for " + synonymUuid);
|
|
695
|
}
|
|
696
|
|
|
697
|
Classification classificationFilter = null;
|
|
698
|
if(classificationUuid != null){
|
|
699
|
try {
|
|
700
|
classificationFilter = classificationDao.load(classificationUuid);
|
|
701
|
} catch (NullPointerException e){
|
|
702
|
//TODO not sure, why an NPE should be thrown in the above load method
|
|
703
|
throw new EntityNotFoundException("No Classification entity found for " + classificationUuid);
|
|
704
|
}
|
|
705
|
if(classificationFilter == null){
|
|
706
|
throw new EntityNotFoundException("No Classification entity found for " + classificationUuid);
|
|
707
|
}
|
|
708
|
}
|
|
709
|
|
|
710
|
long count = dao.countAcceptedTaxonFor(synonym, classificationFilter) ;
|
|
711
|
if(count > 0){
|
|
712
|
Taxon result = dao.acceptedTaxonFor(synonym, classificationFilter, propertyPaths);
|
|
713
|
checkPublished(result, includeUnpublished, "Accepted taxon unpublished");
|
|
714
|
return result;
|
|
715
|
}else{
|
|
716
|
return null;
|
|
717
|
}
|
|
718
|
}
|
|
719
|
|
|
720
|
@Override
|
|
721
|
public Set<Taxon> listRelatedTaxa(Taxon taxon, Set<TaxonRelationshipEdge> includeRelationships, Integer maxDepth,
|
|
722
|
boolean includeUnpublished, Integer limit, Integer start, List<String> propertyPaths) {
|
|
723
|
|
|
724
|
Set<Taxon> relatedTaxa = collectRelatedTaxa(taxon, includeRelationships, new HashSet<>(), includeUnpublished, maxDepth);
|
|
725
|
relatedTaxa.remove(taxon);
|
|
726
|
beanInitializer.initializeAll(relatedTaxa, propertyPaths);
|
|
727
|
return relatedTaxa;
|
|
728
|
}
|
|
729
|
|
|
730
|
/**
|
|
731
|
* Recursively collect related taxa for the given <code>taxon</code> . The returned list will also include the
|
|
732
|
* <code>taxon</code> supplied as parameter.
|
|
733
|
*
|
|
734
|
* @param taxon
|
|
735
|
* @param includeRelationships
|
|
736
|
* @param taxa
|
|
737
|
* @param maxDepth can be <code>null</code> for infinite depth
|
|
738
|
* @return
|
|
739
|
*/
|
|
740
|
private Set<Taxon> collectRelatedTaxa(Taxon taxon, Set<TaxonRelationshipEdge> includeRelationships, Set<Taxon> taxa,
|
|
741
|
boolean includeUnpublished, Integer maxDepth) {
|
|
742
|
|
|
743
|
if(taxa.isEmpty()) {
|
|
744
|
taxa.add(taxon);
|
|
745
|
}
|
|
746
|
|
|
747
|
if(includeRelationships.isEmpty()){
|
|
748
|
return taxa;
|
|
749
|
}
|
|
750
|
|
|
751
|
if(maxDepth != null) {
|
|
752
|
maxDepth--;
|
|
753
|
}
|
|
754
|
if(logger.isDebugEnabled()){
|
|
755
|
logger.debug("collecting related taxa for " + taxon + " with maxDepth=" + maxDepth);
|
|
756
|
}
|
|
757
|
List<TaxonRelationship> taxonRelationships = dao.getTaxonRelationships(taxon,
|
|
758
|
(Set<TaxonRelationshipType>)null, includeUnpublished, null, null, null, null, null);
|
|
759
|
for (TaxonRelationship taxRel : taxonRelationships) {
|
|
760
|
|
|
761
|
// skip invalid data
|
|
762
|
if (taxRel.getToTaxon() == null || taxRel.getFromTaxon() == null || taxRel.getType() == null) {
|
|
763
|
continue;
|
|
764
|
}
|
|
765
|
// filter by includeRelationships
|
|
766
|
for (TaxonRelationshipEdge relationshipEdgeFilter : includeRelationships) {
|
|
767
|
if ( relationshipEdgeFilter.getRelationshipTypes().equals(taxRel.getType()) ) {
|
|
768
|
if (relationshipEdgeFilter.getDirections().contains(Direction.relatedTo) && !taxa.contains(taxRel.getToTaxon())) {
|
|
769
|
if(logger.isDebugEnabled()){
|
|
770
|
logger.debug(maxDepth + ": " + taxon.getTitleCache() + " --[" + taxRel.getType().getLabel() + "]--> " + taxRel.getToTaxon().getTitleCache());
|
|
771
|
}
|
|
772
|
taxa.add(taxRel.getToTaxon());
|
|
773
|
if(maxDepth == null || maxDepth > 0) {
|
|
774
|
taxa.addAll(collectRelatedTaxa(taxRel.getToTaxon(), includeRelationships, taxa, includeUnpublished, maxDepth));
|
|
775
|
}
|
|
776
|
}
|
|
777
|
if(relationshipEdgeFilter.getDirections().contains(Direction.relatedFrom) && !taxa.contains(taxRel.getFromTaxon())) {
|
|
778
|
taxa.add(taxRel.getFromTaxon());
|
|
779
|
if(logger.isDebugEnabled()){
|
|
780
|
logger.debug(maxDepth + ": " +taxRel.getFromTaxon().getTitleCache() + " --[" + taxRel.getType().getLabel() + "]--> " + taxon.getTitleCache() );
|
|
781
|
}
|
|
782
|
if(maxDepth == null || maxDepth > 0) {
|
|
783
|
taxa.addAll(collectRelatedTaxa(taxRel.getFromTaxon(), includeRelationships, taxa, includeUnpublished, maxDepth));
|
|
784
|
}
|
|
785
|
}
|
|
786
|
}
|
|
787
|
}
|
|
788
|
}
|
|
789
|
return taxa;
|
|
790
|
}
|
|
791
|
|
|
792
|
@Override
|
|
793
|
public Pager<Synonym> getSynonyms(Taxon taxon, SynonymType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
|
|
794
|
Long numberOfResults = dao.countSynonyms(taxon, type);
|
|
795
|
|
|
796
|
List<Synonym> results = new ArrayList<>();
|
|
797
|
if(numberOfResults > 0) { // no point checking again
|
|
798
|
results = dao.getSynonyms(taxon, type, pageSize, pageNumber, orderHints, propertyPaths);
|
|
799
|
}
|
|
800
|
|
|
801
|
return new DefaultPagerImpl<>(pageNumber, numberOfResults, pageSize, results);
|
|
802
|
}
|
|
803
|
|
|
804
|
@Override
|
|
805
|
public List<List<Synonym>> getSynonymsByHomotypicGroup(Taxon taxon, List<String> propertyPaths){
|
|
806
|
List<List<Synonym>> result = new ArrayList<>();
|
|
807
|
taxon = (Taxon)dao.load(taxon.getUuid(), propertyPaths);
|
|
808
|
HomotypicGroupTaxonComparator comparator = new HomotypicGroupTaxonComparator(taxon);
|
|
809
|
|
|
810
|
//homotypic
|
|
811
|
result.add(taxon.getHomotypicSynonymsByHomotypicGroup(comparator));
|
|
812
|
|
|
813
|
//heterotypic
|
|
814
|
List<HomotypicalGroup> homotypicalGroups = taxon.getHeterotypicSynonymyGroups(); //currently the list is sorted by the Taxon.defaultTaxonComparator
|
|
815
|
for(HomotypicalGroup homotypicalGroup : homotypicalGroups){
|
|
816
|
result.add(taxon.getSynonymsInGroup(homotypicalGroup, comparator));
|
|
817
|
}
|
|
818
|
|
|
819
|
return result;
|
|
820
|
}
|
|
821
|
|
|
822
|
@Override
|
|
823
|
public List<Synonym> getHomotypicSynonymsByHomotypicGroup(Taxon taxon, List<String> propertyPaths){
|
|
824
|
Taxon t = (Taxon)dao.load(taxon.getUuid(), propertyPaths);
|
|
825
|
HomotypicGroupTaxonComparator comparator = new HomotypicGroupTaxonComparator(taxon);
|
|
826
|
|
|
827
|
return t.getHomotypicSynonymsByHomotypicGroup(comparator);
|
|
828
|
}
|
|
829
|
|
|
830
|
@Override
|
|
831
|
public List<List<Synonym>> getHeterotypicSynonymyGroups(Taxon taxon, List<String> propertyPaths){
|
|
832
|
Taxon t = (Taxon)dao.load(taxon.getUuid(), propertyPaths);
|
|
833
|
List<HomotypicalGroup> homotypicalGroups = t.getHeterotypicSynonymyGroups();
|
|
834
|
List<List<Synonym>> heterotypicSynonymyGroups = new ArrayList<>(homotypicalGroups.size());
|
|
835
|
for(HomotypicalGroup homotypicalGroup : homotypicalGroups){
|
|
836
|
heterotypicSynonymyGroups.add(t.getSynonymsInGroup(homotypicalGroup));
|
|
837
|
}
|
|
838
|
return heterotypicSynonymyGroups;
|
|
839
|
}
|
|
840
|
|
|
841
|
@Override
|
|
842
|
public List<UuidAndTitleCache<? extends IdentifiableEntity>> findTaxaAndNamesForEditor(IFindTaxaAndNamesConfigurator config){
|
|
843
|
|
|
844
|
if (config.isDoSynonyms() || config.isDoTaxa() || config.isDoNamesWithoutTaxa() || config.isDoTaxaByCommonNames()){
|
|
845
|
return dao.getTaxaByNameForEditor(config.isDoTaxa(), config.isDoSynonyms(), config.isDoNamesWithoutTaxa(),
|
|
846
|
config.isDoMisappliedNames(), config.isDoTaxaByCommonNames(), config.isIncludeUnpublished(), config.isDoIncludeAuthors(),
|
|
847
|
config.getTitleSearchStringSqlized(), config.getClassification(), config.getSubtree(),
|
|
848
|
config.getMatchMode(), config.getNamedAreas(), config.getOrder());
|
|
849
|
}else{
|
|
850
|
return new ArrayList<>();
|
|
851
|
}
|
|
852
|
}
|
|
853
|
|
|
854
|
@Override
|
|
855
|
public Pager<IdentifiableEntity> findTaxaAndNames(IFindTaxaAndNamesConfigurator configurator) {
|
|
856
|
|
|
857
|
@SuppressWarnings("rawtypes")
|
|
858
|
List<IdentifiableEntity> results = new ArrayList<>();
|
|
859
|
long numberOfResults = 0; // overall number of results (as opposed to number of results per page)
|
|
860
|
List<TaxonBase> taxa = null;
|
|
861
|
|
|
862
|
// Taxa and synonyms
|
|
863
|
long numberTaxaResults = 0L;
|
|
864
|
|
|
865
|
List<String> propertyPath = new ArrayList<>();
|
|
866
|
if(configurator.getTaxonPropertyPath() != null){
|
|
867
|
propertyPath.addAll(configurator.getTaxonPropertyPath());
|
|
868
|
}
|
|
869
|
|
|
870
|
if (configurator.isDoMisappliedNames() || configurator.isDoSynonyms() || configurator.isDoTaxa() || configurator.isDoTaxaByCommonNames()){
|
|
871
|
if(configurator.getPageSize() != null){ // no point counting if we need all anyway
|
|
872
|
numberTaxaResults =
|
|
873
|
dao.countTaxaByName(configurator.isDoTaxa(),configurator.isDoSynonyms(), configurator.isDoMisappliedNames(),
|
|
874
|
configurator.isDoTaxaByCommonNames(), configurator.isDoIncludeAuthors(), configurator.getTitleSearchStringSqlized(),
|
|
875
|
configurator.getClassification(), configurator.getSubtree(), configurator.getMatchMode(),
|
|
876
|
configurator.getNamedAreas(), configurator.isIncludeUnpublished());
|
|
877
|
}
|
|
878
|
|
|
879
|
if(configurator.getPageSize() == null || numberTaxaResults > configurator.getPageSize() * configurator.getPageNumber()){ // no point checking again if less results
|
|
880
|
taxa = dao.getTaxaByName(configurator.isDoTaxa(), configurator.isDoSynonyms(),
|
|
881
|
configurator.isDoMisappliedNames(), configurator.isDoTaxaByCommonNames(), configurator.isDoIncludeAuthors(),
|
|
882
|
configurator.getTitleSearchStringSqlized(), configurator.getClassification(), configurator.getSubtree(),
|
|
883
|
configurator.getMatchMode(), configurator.getNamedAreas(), configurator.isIncludeUnpublished(),
|
|
884
|
configurator.getOrder(), configurator.getPageSize(), configurator.getPageNumber(), propertyPath);
|
|
885
|
}
|
|
886
|
}
|
|
887
|
|
|
888
|
if (logger.isDebugEnabled()) { logger.debug(numberTaxaResults + " matching taxa counted"); }
|
|
889
|
|
|
890
|
if(taxa != null){
|
|
891
|
results.addAll(taxa);
|
|
892
|
}
|
|
893
|
|
|
894
|
numberOfResults += numberTaxaResults;
|
|
895
|
|
|
896
|
// Names without taxa
|
|
897
|
if (configurator.isDoNamesWithoutTaxa()) {
|
|
898
|
int numberNameResults = 0;
|
|
899
|
|
|
900
|
List<TaxonName> names =
|
|
901
|
nameDao.findByName(configurator.isDoIncludeAuthors(), configurator.getTitleSearchStringSqlized(), configurator.getMatchMode(),
|
|
902
|
configurator.getPageSize(), configurator.getPageNumber(), null, configurator.getTaxonNamePropertyPath());
|
|
903
|
if (logger.isDebugEnabled()) { logger.debug(names.size() + " matching name(s) found"); }
|
|
904
|
if (names.size() > 0) {
|
|
905
|
for (TaxonName taxonName : names) {
|
|
906
|
if (taxonName.getTaxonBases().size() == 0) {
|
|
907
|
results.add(taxonName);
|
|
908
|
numberNameResults++;
|
|
909
|
}
|
|
910
|
}
|
|
911
|
if (logger.isDebugEnabled()) { logger.debug(numberNameResults + " matching name(s) without taxa found"); }
|
|
912
|
numberOfResults += numberNameResults;
|
|
913
|
}
|
|
914
|
}
|
|
915
|
|
|
916
|
return new DefaultPagerImpl<> (configurator.getPageNumber(), numberOfResults, configurator.getPageSize(), results);
|
|
917
|
}
|
|
918
|
|
|
919
|
public List<UuidAndTitleCache<TaxonBase>> getTaxonUuidAndTitleCache(Integer limit, String pattern){
|
|
920
|
return dao.getUuidAndTitleCache(limit, pattern);
|
|
921
|
}
|
|
922
|
|
|
923
|
@Override
|
|
924
|
public List<Media> listTaxonDescriptionMedia(Taxon taxon, Set<TaxonRelationshipEdge> includeRelationships, boolean limitToGalleries, List<String> propertyPath){
|
|
925
|
return listMedia(taxon, includeRelationships, limitToGalleries, true, false, false, propertyPath);
|
|
926
|
}
|
|
927
|
|
|
928
|
@Override
|
|
929
|
public List<Media> listMedia(Taxon taxon, Set<TaxonRelationshipEdge> includeRelationships,
|
|
930
|
Boolean limitToGalleries, Boolean includeTaxonDescriptions, Boolean includeOccurrences,
|
|
931
|
Boolean includeTaxonNameDescriptions, List<String> propertyPath) {
|
|
932
|
|
|
933
|
//TODO let inherit
|
|
934
|
boolean includeUnpublished = INCLUDE_UNPUBLISHED;
|
|
935
|
|
|
936
|
// logger.setLevel(Level.TRACE);
|
|
937
|
// Logger.getLogger("org.hibernate.SQL").setLevel(Level.TRACE);
|
|
938
|
|
|
939
|
logger.trace("listMedia() - START");
|
|
940
|
|
|
941
|
Set<Taxon> taxa = new HashSet<>();
|
|
942
|
List<Media> taxonMedia = new ArrayList<>();
|
|
943
|
List<Media> nonImageGalleryImages = new ArrayList<>();
|
|
944
|
|
|
945
|
if (limitToGalleries == null) {
|
|
946
|
limitToGalleries = false;
|
|
947
|
}
|
|
948
|
|
|
949
|
// --- resolve related taxa
|
|
950
|
if (includeRelationships != null && ! includeRelationships.isEmpty()) {
|
|
951
|
logger.trace("listMedia() - resolve related taxa");
|
|
952
|
taxa = listRelatedTaxa(taxon, includeRelationships, null, includeUnpublished, null, null, null);
|
|
953
|
}
|
|
954
|
|
|
955
|
taxa.add((Taxon) dao.load(taxon.getUuid()));
|
|
956
|
|
|
957
|
if(includeTaxonDescriptions != null && includeTaxonDescriptions){
|
|
958
|
logger.trace("listMedia() - includeTaxonDescriptions");
|
|
959
|
List<TaxonDescription> taxonDescriptions = new ArrayList<>();
|
|
960
|
// --- TaxonDescriptions
|
|
961
|
for (Taxon t : taxa) {
|
|
962
|
taxonDescriptions.addAll(descriptionService.listTaxonDescriptions(t, null, null, null, null, propertyPath));
|
|
963
|
}
|
|
964
|
for (TaxonDescription taxonDescription : taxonDescriptions) {
|
|
965
|
if (!limitToGalleries || taxonDescription.isImageGallery()) {
|
|
966
|
for (DescriptionElementBase element : taxonDescription.getElements()) {
|
|
967
|
for (Media media : element.getMedia()) {
|
|
968
|
if(taxonDescription.isImageGallery()){
|
|
969
|
taxonMedia.add(media);
|
|
970
|
}
|
|
971
|
else{
|
|
972
|
nonImageGalleryImages.add(media);
|
|
973
|
}
|
|
974
|
}
|
|
975
|
}
|
|
976
|
}
|
|
977
|
}
|
|
978
|
//put images from image gallery first (#3242)
|
|
979
|
taxonMedia.addAll(nonImageGalleryImages);
|
|
980
|
}
|
|
981
|
|
|
982
|
|
|
983
|
if(includeOccurrences != null && includeOccurrences) {
|
|
984
|
logger.trace("listMedia() - includeOccurrences");
|
|
985
|
@SuppressWarnings("rawtypes")
|
|
986
|
Set<SpecimenOrObservationBase> specimensOrObservations = new HashSet<>();
|
|
987
|
// --- Specimens
|
|
988
|
for (Taxon t : taxa) {
|
|
989
|
specimensOrObservations.addAll(occurrenceDao.listByAssociatedTaxon(null, t, null, null, null, null));
|
|
990
|
}
|
|
991
|
for (SpecimenOrObservationBase<?> occurrence : specimensOrObservations) {
|
|
992
|
|
|
993
|
// direct media removed from specimen #3597
|
|
994
|
// taxonMedia.addAll(occurrence.getMedia());
|
|
995
|
|
|
996
|
// SpecimenDescriptions
|
|
997
|
Set<SpecimenDescription> specimenDescriptions = occurrence.getSpecimenDescriptions();
|
|
998
|
for (DescriptionBase<?> specimenDescription : specimenDescriptions) {
|
|
999
|
if (!limitToGalleries || specimenDescription.isImageGallery()) {
|
|
1000
|
Set<DescriptionElementBase> elements = specimenDescription.getElements();
|
|
1001
|
for (DescriptionElementBase element : elements) {
|
|
1002
|
for (Media media : element.getMedia()) {
|
|
1003
|
taxonMedia.add(media);
|
|
1004
|
}
|
|
1005
|
}
|
|
1006
|
}
|
|
1007
|
}
|
|
1008
|
|
|
1009
|
if (occurrence.isInstanceOf(DerivedUnit.class)) {
|
|
1010
|
DerivedUnit derivedUnit = CdmBase.deproxy(occurrence, DerivedUnit.class);
|
|
1011
|
// Collection
|
|
1012
|
//TODO why may collections have media attached? #
|
|
1013
|
if (derivedUnit.getCollection() != null){
|
|
1014
|
taxonMedia.addAll(derivedUnit.getCollection().getMedia());
|
|
1015
|
}
|
|
1016
|
}
|
|
1017
|
//media in hierarchy
|
|
1018
|
taxonMedia.addAll(occurrenceService.getMediainHierarchy(occurrence, null, null, propertyPath).getRecords());
|
|
1019
|
}
|
|
1020
|
}
|
|
1021
|
|
|
1022
|
if(includeTaxonNameDescriptions != null && includeTaxonNameDescriptions) {
|
|
1023
|
logger.trace("listMedia() - includeTaxonNameDescriptions");
|
|
1024
|
// --- TaxonNameDescription
|
|
1025
|
Set<TaxonNameDescription> nameDescriptions = new HashSet<>();
|
|
1026
|
for (Taxon t : taxa) {
|
|
1027
|
nameDescriptions .addAll(t.getName().getDescriptions());
|
|
1028
|
}
|
|
1029
|
for(TaxonNameDescription nameDescription: nameDescriptions){
|
|
1030
|
if (!limitToGalleries || nameDescription.isImageGallery()) {
|
|
1031
|
Set<DescriptionElementBase> elements = nameDescription.getElements();
|
|
1032
|
for (DescriptionElementBase element : elements) {
|
|
1033
|
for (Media media : element.getMedia()) {
|
|
1034
|
taxonMedia.add(media);
|
|
1035
|
}
|
|
1036
|
}
|
|
1037
|
}
|
|
1038
|
}
|
|
1039
|
}
|
|
1040
|
|
|
1041
|
logger.trace("listMedia() - initialize");
|
|
1042
|
beanInitializer.initializeAll(taxonMedia, propertyPath);
|
|
1043
|
|
|
1044
|
logger.trace("listMedia() - END");
|
|
1045
|
|
|
1046
|
return taxonMedia;
|
|
1047
|
}
|
|
1048
|
|
|
1049
|
@Override
|
|
1050
|
public List<TaxonBase> findTaxaByID(Set<Integer> listOfIDs) {
|
|
1051
|
return this.dao.loadList(listOfIDs, null, null);
|
|
1052
|
}
|
|
1053
|
|
|
1054
|
@Override
|
|
1055
|
public TaxonBase findTaxonByUuid(UUID uuid, List<String> propertyPaths){
|
|
1056
|
return this.dao.findByUuid(uuid, null ,propertyPaths);
|
|
1057
|
}
|
|
1058
|
|
|
1059
|
@Override
|
|
1060
|
public long countSynonyms(boolean onlyAttachedToTaxon){
|
|
1061
|
return this.dao.countSynonyms(onlyAttachedToTaxon);
|
|
1062
|
}
|
|
1063
|
|
|
1064
|
@Override
|
|
1065
|
@Transactional(readOnly=false)
|
|
1066
|
public DeleteResult deleteTaxon(UUID taxonUUID, TaxonDeletionConfigurator config, UUID classificationUuid) {
|
|
1067
|
|
|
1068
|
if (config == null){
|
|
1069
|
config = new TaxonDeletionConfigurator();
|
|
1070
|
}
|
|
1071
|
Taxon taxon = (Taxon)dao.load(taxonUUID);
|
|
1072
|
DeleteResult result = new DeleteResult();
|
|
1073
|
if (taxon == null){
|
|
1074
|
result.setAbort();
|
|
1075
|
result.addException(new Exception ("The taxon was already deleted."));
|
|
1076
|
return result;
|
|
1077
|
}
|
|
1078
|
taxon = HibernateProxyHelper.deproxy(taxon);
|
|
1079
|
Classification classification = HibernateProxyHelper.deproxy(classificationDao.load(classificationUuid), Classification.class);
|
|
1080
|
config.setClassificationUuid(classificationUuid);
|
|
1081
|
result = isDeletable(taxonUUID, config);
|
|
1082
|
|
|
1083
|
if (result.isOk()){
|
|
1084
|
// --- DeleteSynonymRelations
|
|
1085
|
if (config.isDeleteSynonymRelations()){
|
|
1086
|
boolean removeSynonymNameFromHomotypicalGroup = false;
|
|
1087
|
// use tmp Set to avoid concurrent modification
|
|
1088
|
Set<Synonym> synsToDelete = new HashSet<>();
|
|
1089
|
synsToDelete.addAll(taxon.getSynonyms());
|
|
1090
|
for (Synonym synonym : synsToDelete){
|
|
1091
|
taxon.removeSynonym(synonym, removeSynonymNameFromHomotypicalGroup);
|
|
1092
|
|
|
1093
|
// --- DeleteSynonymsIfPossible
|
|
1094
|
if (config.isDeleteSynonymsIfPossible()){
|
|
1095
|
//TODO which value
|
|
1096
|
boolean newHomotypicGroupIfNeeded = true;
|
|
1097
|
SynonymDeletionConfigurator synConfig = new SynonymDeletionConfigurator();
|
|
1098
|
result.includeResult(deleteSynonym(synonym, synConfig));
|
|
1099
|
}
|
|
1100
|
}
|
|
1101
|
}
|
|
1102
|
|
|
1103
|
// --- DeleteTaxonRelationships
|
|
1104
|
if (! config.isDeleteTaxonRelationships()){
|
|
1105
|
if (taxon.getTaxonRelations().size() > 0){
|
|
1106
|
result.setAbort();
|
|
1107
|
result.addException(new Exception("Taxon can't be deleted as it is related to another taxon. " +
|
|
1108
|
"Remove taxon from all relations to other taxa prior to deletion."));
|
|
1109
|
}
|
|
1110
|
} else{
|
|
1111
|
TaxonDeletionConfigurator configRelTaxon = new TaxonDeletionConfigurator();
|
|
1112
|
configRelTaxon.setDeleteTaxonNodes(false);
|
|
1113
|
configRelTaxon.setDeleteConceptRelationships(true);
|
|
1114
|
|
|
1115
|
for (TaxonRelationship taxRel: taxon.getTaxonRelations()){
|
|
1116
|
if (config.isDeleteMisappliedNames()
|
|
1117
|
&& taxRel.getType().isMisappliedName()
|
|
1118
|
&& taxon.equals(taxRel.getToTaxon())){
|
|
1119
|
this.deleteTaxon(taxRel.getFromTaxon().getUuid(), config, classificationUuid);
|
|
1120
|
} else if (config.isDeleteConceptRelationships() && taxRel.getType().isConceptRelationship()){
|
|
1121
|
|
|
1122
|
if (taxon.equals(taxRel.getToTaxon()) && isDeletable(taxRel.getFromTaxon().getUuid(), configRelTaxon).isOk()){
|
|
1123
|
this.deleteTaxon(taxRel.getFromTaxon().getUuid(), configRelTaxon, classificationUuid);
|
|
1124
|
}else if (isDeletable(taxRel.getToTaxon().getUuid(), configRelTaxon).isOk()){
|
|
1125
|
this.deleteTaxon(taxRel.getToTaxon().getUuid(), configRelTaxon, classificationUuid);
|
|
1126
|
}
|
|
1127
|
}
|
|
1128
|
taxon.removeTaxonRelation(taxRel);
|
|
1129
|
}
|
|
1130
|
}
|
|
1131
|
|
|
1132
|
// TaxonDescription
|
|
1133
|
if (config.isDeleteDescriptions()){
|
|
1134
|
Set<TaxonDescription> descriptions = taxon.getDescriptions();
|
|
1135
|
List<TaxonDescription> removeDescriptions = new ArrayList<>();
|
|
1136
|
for (TaxonDescription desc: descriptions){
|
|
1137
|
//TODO use description delete configurator ?
|
|
1138
|
//FIXME check if description is ALWAYS deletable
|
|
1139
|
if (desc.getDescribedSpecimenOrObservation() != null){
|
|
1140
|
result.setAbort();
|
|
1141
|
result.addException(new Exception("Taxon can't be deleted as it is used in a TaxonDescription" +
|
|
1142
|
" which also describes specimens or observations"));
|
|
1143
|
break;
|
|
1144
|
}
|
|
1145
|
removeDescriptions.add(desc);
|
|
1146
|
}
|
|
1147
|
if (result.isOk()){
|
|
1148
|
for (TaxonDescription desc: removeDescriptions){
|
|
1149
|
taxon.removeDescription(desc);
|
|
1150
|
descriptionService.delete(desc);
|
|
1151
|
}
|
|
1152
|
} else {
|
|
1153
|
return result;
|
|
1154
|
}
|
|
1155
|
}
|
|
1156
|
|
|
1157
|
if (! config.isDeleteTaxonNodes() || (!config.isDeleteInAllClassifications() && classification == null && taxon.getTaxonNodes().size() > 1)){
|
|
1158
|
result.addException(new Exception( "Taxon can't be deleted as it is used in more than one classification."));
|
|
1159
|
}else{
|
|
1160
|
if (taxon.getTaxonNodes().size() != 0){
|
|
1161
|
Set<TaxonNode> nodes = taxon.getTaxonNodes();
|
|
1162
|
Iterator<TaxonNode> iterator = nodes.iterator();
|
|
1163
|
TaxonNode node = null;
|
|
1164
|
boolean deleteChildren;
|
|
1165
|
if (config.getTaxonNodeConfig().getChildHandling().equals(ChildHandling.DELETE)){
|
|
1166
|
deleteChildren = true;
|
|
1167
|
}else {
|
|
1168
|
deleteChildren = false;
|
|
1169
|
}
|
|
1170
|
boolean success = true;
|
|
1171
|
if (!config.isDeleteInAllClassifications() && !(classification == null)){
|
|
1172
|
while (iterator.hasNext()){
|
|
1173
|
node = iterator.next();
|
|
1174
|
if (node.getClassification().equals(classification)){
|
|
1175
|
break;
|
|
1176
|
}
|
|
1177
|
node = null;
|
|
1178
|
}
|
|
1179
|
if (node != null){
|
|
1180
|
HibernateProxyHelper.deproxy(node, TaxonNode.class);
|
|
1181
|
success =taxon.removeTaxonNode(node, deleteChildren);
|
|
1182
|
nodeService.delete(node);
|
|
1183
|
result.addDeletedObject(node);
|
|
1184
|
} else {
|
|
1185
|
result.setError();
|
|
1186
|
result.addException(new Exception("The taxon can not be deleted because it is not used in defined classification."));
|
|
1187
|
}
|
|
1188
|
} else if (config.isDeleteInAllClassifications()){
|
|
1189
|
List<TaxonNode> nodesList = new ArrayList<>();
|
|
1190
|
nodesList.addAll(taxon.getTaxonNodes());
|
|
1191
|
for (ITaxonTreeNode treeNode: nodesList){
|
|
1192
|
TaxonNode taxonNode = (TaxonNode) treeNode;
|
|
1193
|
if(!deleteChildren){
|
|
1194
|
Object[] childNodes = taxonNode.getChildNodes().toArray();
|
|
1195
|
for (Object childNode: childNodes){
|
|
1196
|
TaxonNode childNodeCast = (TaxonNode) childNode;
|
|
1197
|
taxonNode.getParent().addChildNode(childNodeCast, childNodeCast.getReference(), childNodeCast.getMicroReference());
|
|
1198
|
}
|
|
1199
|
}
|
|
1200
|
}
|
|
1201
|
config.getTaxonNodeConfig().setDeleteElement(false);
|
|
1202
|
DeleteResult resultNodes = nodeService.deleteTaxonNodes(nodesList, config);
|
|
1203
|
if (!resultNodes.isOk()){
|
|
1204
|
result.addExceptions(resultNodes.getExceptions());
|
|
1205
|
result.setStatus(resultNodes.getStatus());
|
|
1206
|
} else {
|
|
1207
|
result.addUpdatedObjects(resultNodes.getUpdatedObjects());
|
|
1208
|
}
|
|
1209
|
}
|
|
1210
|
if (!success){
|
|
1211
|
result.setError();
|
|
1212
|
result.addException(new Exception("The taxon can not be deleted because the taxon node can not be removed."));
|
|
1213
|
}
|
|
1214
|
}
|
|
1215
|
}
|
|
1216
|
TaxonName name = taxon.getName();
|
|
1217
|
taxon.setName(null);
|
|
1218
|
this.saveOrUpdate(taxon);
|
|
1219
|
|
|
1220
|
if ((taxon.getTaxonNodes() == null || taxon.getTaxonNodes().size()== 0) && result.isOk()){
|
|
1221
|
try{
|
|
1222
|
dao.delete(taxon);
|
|
1223
|
result.addDeletedObject(taxon);
|
|
1224
|
}catch(Exception e){
|
|
1225
|
result.addException(e);
|
|
1226
|
result.setError();
|
|
1227
|
}
|
|
1228
|
} else {
|
|
1229
|
result.setError();
|
|
1230
|
result.addException(new Exception("The Taxon can't be deleted because it is used in a classification."));
|
|
1231
|
|
|
1232
|
}
|
|
1233
|
//TaxonName
|
|
1234
|
if (config.isDeleteNameIfPossible() && result.isOk()){
|
|
1235
|
DeleteResult nameResult = new DeleteResult();
|
|
1236
|
//remove name if possible (and required)
|
|
1237
|
if (name != null ){
|
|
1238
|
nameResult = nameService.delete(name.getUuid(), config.getNameDeletionConfig());
|
|
1239
|
}
|
|
1240
|
if (nameResult.isError() || nameResult.isAbort()){
|
|
1241
|
result.addRelatedObject(name);
|
|
1242
|
result.addExceptions(nameResult.getExceptions());
|
|
1243
|
}else{
|
|
1244
|
result.includeResult(nameResult);
|
|
1245
|
}
|
|
1246
|
}
|
|
1247
|
}
|
|
1248
|
|
|
1249
|
return result;
|
|
1250
|
}
|
|
1251
|
|
|
1252
|
@Override
|
|
1253
|
@Transactional(readOnly = false)
|
|
1254
|
public DeleteResult delete(UUID synUUID){
|
|
1255
|
Synonym syn = (Synonym)dao.load(synUUID);
|
|
1256
|
return this.deleteSynonym(syn, null);
|
|
1257
|
}
|
|
1258
|
|
|
1259
|
@Override
|
|
1260
|
@Transactional(readOnly = false)
|
|
1261
|
public DeleteResult deleteSynonym(UUID synonymUuid, SynonymDeletionConfigurator config) {
|
|
1262
|
return deleteSynonym((Synonym)dao.load(synonymUuid), config);
|
|
1263
|
}
|
|
1264
|
|
|
1265
|
@Override
|
|
1266
|
@Transactional(readOnly = false)
|
|
1267
|
public DeleteResult deleteSynonym(Synonym synonym, SynonymDeletionConfigurator config) {
|
|
1268
|
DeleteResult result = new DeleteResult();
|
|
1269
|
if (synonym == null){
|
|
1270
|
result.setAbort();
|
|
1271
|
result.addException(new Exception("The synonym was already deleted."));
|
|
1272
|
return result;
|
|
1273
|
}
|
|
1274
|
|
|
1275
|
if (config == null){
|
|
1276
|
config = new SynonymDeletionConfigurator();
|
|
1277
|
}
|
|
1278
|
|
|
1279
|
result = isDeletable(synonym.getUuid(), config);
|
|
1280
|
|
|
1281
|
if (result.isOk()){
|
|
1282
|
|
|
1283
|
synonym = HibernateProxyHelper.deproxy(this.load(synonym.getUuid()), Synonym.class);
|
|
1284
|
|
|
1285
|
//remove synonym
|
|
1286
|
Taxon accTaxon = synonym.getAcceptedTaxon();
|
|
1287
|
|
|
1288
|
if (accTaxon != null){
|
|
1289
|
accTaxon = HibernateProxyHelper.deproxy(accTaxon, Taxon.class);
|
|
1290
|
accTaxon.removeSynonym(synonym, false);
|
|
1291
|
this.saveOrUpdate(accTaxon);
|
|
1292
|
result.addUpdatedObject(accTaxon);
|
|
1293
|
}
|
|
1294
|
this.saveOrUpdate(synonym);
|
|
1295
|
//#6281
|
|
1296
|
dao.flush();
|
|
1297
|
|
|
1298
|
TaxonName name = synonym.getName();
|
|
1299
|
synonym.setName(null);
|
|
1300
|
|
|
1301
|
dao.delete(synonym);
|
|
1302
|
result.addDeletedObject(synonym);
|
|
1303
|
|
|
1304
|
//remove name if possible (and required)
|
|
1305
|
if (name != null && config.isDeleteNameIfPossible()){
|
|
1306
|
|
|
1307
|
DeleteResult nameDeleteResult = nameService.delete(name, config.getNameDeletionConfig());
|
|
1308
|
if (nameDeleteResult.isAbort() || nameDeleteResult.isError()){
|
|
1309
|
result.addExceptions(nameDeleteResult.getExceptions());
|
|
1310
|
result.addRelatedObject(name);
|
|
1311
|
result.addUpdatedObject(name);
|
|
1312
|
}else{
|
|
1313
|
result.addDeletedObject(name);
|
|
1314
|
}
|
|
1315
|
}
|
|
1316
|
}
|
|
1317
|
return result;
|
|
1318
|
}
|
|
1319
|
|
|
1320
|
@Override
|
|
1321
|
public Map<String, Map<UUID,Set<TaxonName>>> findIdenticalTaxonNames(List<UUID> sourceRefUuids, List<String> propertyPaths) {
|
|
1322
|
return this.dao.findIdenticalNames(sourceRefUuids, propertyPaths);
|
|
1323
|
}
|
|
1324
|
|
|
1325
|
@Override
|
|
1326
|
public Taxon findBestMatchingTaxon(String taxonName) {
|
|
1327
|
MatchingTaxonConfigurator config = MatchingTaxonConfigurator.NewInstance();
|
|
1328
|
config.setTaxonNameTitle(taxonName);
|
|
1329
|
return findBestMatchingTaxon(config);
|
|
1330
|
}
|
|
1331
|
|
|
1332
|
@Override
|
|
1333
|
public Taxon findBestMatchingTaxon(MatchingTaxonConfigurator config) {
|
|
1334
|
|
|
1335
|
Taxon bestCandidate = null;
|
|
1336
|
try{
|
|
1337
|
// 1. search for accepted taxa
|
|
1338
|
List<TaxonBase> taxonList = dao.findByNameTitleCache(true, false, config.isIncludeUnpublished(),
|
|
1339
|
config.getTaxonNameTitle(), null, null, MatchMode.EXACT, null, null, 0, null, null);
|
|
1340
|
boolean bestCandidateMatchesSecUuid = false;
|
|
1341
|
boolean bestCandidateIsInClassification = false;
|
|
1342
|
int countEqualCandidates = 0;
|
|
1343
|
for(TaxonBase<?> taxonBaseCandidate : taxonList){
|
|
1344
|
if(taxonBaseCandidate instanceof Taxon){
|
|
1345
|
Taxon newCanditate = CdmBase.deproxy(taxonBaseCandidate, Taxon.class);
|
|
1346
|
boolean newCandidateMatchesSecUuid = isMatchesSecUuid(newCanditate, config);
|
|
1347
|
if (! newCandidateMatchesSecUuid && config.isOnlyMatchingSecUuid() ){
|
|
1348
|
continue;
|
|
1349
|
}else if(newCandidateMatchesSecUuid && ! bestCandidateMatchesSecUuid){
|
|
1350
|
bestCandidate = newCanditate;
|
|
1351
|
countEqualCandidates = 1;
|
|
1352
|
bestCandidateMatchesSecUuid = true;
|
|
1353
|
continue;
|
|
1354
|
}
|
|
1355
|
|
|
1356
|
boolean newCandidateInClassification = isInClassification(newCanditate, config);
|
|
1357
|
if (! newCandidateInClassification && config.isOnlyMatchingClassificationUuid()){
|
|
1358
|
continue;
|
|
1359
|
}else if (newCandidateInClassification && ! bestCandidateIsInClassification){
|
|
1360
|
bestCandidate = newCanditate;
|
|
1361
|
countEqualCandidates = 1;
|
|
1362
|
bestCandidateIsInClassification = true;
|
|
1363
|
continue;
|
|
1364
|
}
|
|
1365
|
if (bestCandidate == null){
|
|
1366
|
bestCandidate = newCanditate;
|
|
1367
|
countEqualCandidates = 1;
|
|
1368
|
continue;
|
|
1369
|
}
|
|
1370
|
}else{ //not Taxon.class
|
|
1371
|
continue;
|
|
1372
|
}
|
|
1373
|
countEqualCandidates++;
|
|
1374
|
|
|
1375
|
}
|
|
1376
|
if (bestCandidate != null){
|
|
1377
|
if(countEqualCandidates > 1){
|
|
1378
|
logger.info(countEqualCandidates + " equally matching TaxonBases found, using first accepted Taxon: " + bestCandidate.getTitleCache());
|
|
1379
|
return bestCandidate;
|
|
1380
|
} else {
|
|
1381
|
logger.info("using accepted Taxon: " + bestCandidate.getTitleCache());
|
|
1382
|
return bestCandidate;
|
|
1383
|
}
|
|
1384
|
}
|
|
1385
|
|
|
1386
|
// 2. search for synonyms
|
|
1387
|
if (config.isIncludeSynonyms()){
|
|
1388
|
List<TaxonBase> synonymList = dao.findByNameTitleCache(false, true, config.isIncludeUnpublished(),
|
|
1389
|
config.getTaxonNameTitle(), null, null, MatchMode.EXACT, null, null, 0, null, null);
|
|
1390
|
for(TaxonBase taxonBase : synonymList){
|
|
1391
|
if(taxonBase instanceof Synonym){
|
|
1392
|
Synonym synonym = CdmBase.deproxy(taxonBase, Synonym.class);
|
|
1393
|
bestCandidate = synonym.getAcceptedTaxon();
|
|
1394
|
if(bestCandidate != null){
|
|
1395
|
logger.info("using accepted Taxon " + bestCandidate.getTitleCache() + " for synonym " + taxonBase.getTitleCache());
|
|
1396
|
return bestCandidate;
|
|
1397
|
}
|
|
1398
|
//TODO extend method: search using treeUUID, using SecUUID, first find accepted then include synonyms until a matching taxon is found
|
|
1399
|
}
|
|
1400
|
}
|
|
1401
|
}
|
|
1402
|
|
|
1403
|
} catch (Exception e){
|
|
1404
|
logger.error(e);
|
|
1405
|
e.printStackTrace();
|
|
1406
|
}
|
|
1407
|
|
|
1408
|
return bestCandidate;
|
|
1409
|
}
|
|
1410
|
|
|
1411
|
private boolean isInClassification(Taxon taxon, MatchingTaxonConfigurator config) {
|
|
1412
|
UUID configClassificationUuid = config.getClassificationUuid();
|
|
1413
|
if (configClassificationUuid == null){
|
|
1414
|
return false;
|
|
1415
|
}
|
|
1416
|
for (TaxonNode node : taxon.getTaxonNodes()){
|
|
1417
|
UUID classUuid = node.getClassification().getUuid();
|
|
1418
|
if (configClassificationUuid.equals(classUuid)){
|
|
1419
|
return true;
|
|
1420
|
}
|
|
1421
|
}
|
|
1422
|
return false;
|
|
1423
|
}
|
|
1424
|
|
|
1425
|
private boolean isMatchesSecUuid(Taxon taxon, MatchingTaxonConfigurator config) {
|
|
1426
|
UUID configSecUuid = config.getSecUuid();
|
|
1427
|
if (configSecUuid == null){
|
|
1428
|
return false;
|
|
1429
|
}
|
|
1430
|
UUID taxonSecUuid = (taxon.getSec() == null)? null : taxon.getSec().getUuid();
|
|
1431
|
return configSecUuid.equals(taxonSecUuid);
|
|
1432
|
}
|
|
1433
|
|
|
1434
|
@Override
|
|
1435
|
public Synonym findBestMatchingSynonym(String taxonName, boolean includeUnpublished) {
|
|
1436
|
List<TaxonBase> synonymList = dao.findByNameTitleCache(false, true, includeUnpublished, taxonName, null, null, MatchMode.EXACT, null, null, 0, null, null);
|
|
1437
|
if(! synonymList.isEmpty()){
|
|
1438
|
Synonym result = CdmBase.deproxy(synonymList.iterator().next(), Synonym.class);
|
|
1439
|
if(synonymList.size() == 1){
|
|
1440
|
logger.info(synonymList.size() + " Synonym found " + result.getTitleCache() );
|
|
1441
|
return result;
|
|
1442
|
} else {
|
|
1443
|
logger.info("Several matching synonyms found. Using first: " + result.getTitleCache());
|
|
1444
|
return result;
|
|
1445
|
}
|
|
1446
|
}
|
|
1447
|
return null;
|
|
1448
|
}
|
|
1449
|
|
|
1450
|
@Override
|
|
1451
|
@Transactional(readOnly = false)
|
|
1452
|
public UpdateResult moveSynonymToAnotherTaxon(Synonym oldSynonym, UUID newTaxonUUID, boolean moveHomotypicGroup,
|
|
1453
|
SynonymType newSynonymType, UUID newSecundumUuid, String newSecundumDetail,
|
|
1454
|
boolean keepSecundumIfUndefined) throws HomotypicalGroupChangeException {
|
|
1455
|
|
|
1456
|
UpdateResult result = new UpdateResult();
|
|
1457
|
Taxon newTaxon = CdmBase.deproxy(dao.load(newTaxonUUID), Taxon.class);
|
|
1458
|
result = moveSynonymToAnotherTaxon(oldSynonym, newTaxon, moveHomotypicGroup, newSynonymType,
|
|
1459
|
newSecundumUuid, newSecundumDetail, keepSecundumIfUndefined);
|
|
1460
|
|
|
1461
|
return result;
|
|
1462
|
}
|
|
1463
|
|
|
1464
|
@Override
|
|
1465
|
@Transactional(readOnly = false)
|
|
1466
|
public UpdateResult moveSynonymToAnotherTaxon(Synonym oldSynonym,
|
|
1467
|
Taxon newTaxon,
|
|
1468
|
boolean moveHomotypicGroup,
|
|
1469
|
SynonymType newSynonymType) throws HomotypicalGroupChangeException {
|
|
1470
|
return moveSynonymToAnotherTaxon(oldSynonym, newTaxon, moveHomotypicGroup,
|
|
1471
|
newSynonymType,
|
|
1472
|
oldSynonym.getSec()!= null? oldSynonym.getSec().getUuid(): null,
|
|
1473
|
oldSynonym.getSecMicroReference(),
|
|
1474
|
true);
|
|
1475
|
}
|
|
1476
|
|
|
1477
|
@Override
|
|
1478
|
@Transactional(readOnly = false)
|
|
1479
|
public UpdateResult moveSynonymToAnotherTaxon(Synonym oldSynonym,
|
|
1480
|
Taxon newTaxon,
|
|
1481
|
boolean moveHomotypicGroup,
|
|
1482
|
SynonymType newSynonymType,
|
|
1483
|
UUID newSecundumUuid,
|
|
1484
|
String newSecundumDetail,
|
|
1485
|
boolean keepSecundumIfUndefined) throws HomotypicalGroupChangeException {
|
|
1486
|
|
|
1487
|
Synonym synonym = CdmBase.deproxy(dao.load(oldSynonym.getUuid()), Synonym.class);
|
|
1488
|
Taxon oldTaxon = CdmBase.deproxy(dao.load(synonym.getAcceptedTaxon().getUuid()), Taxon.class);
|
|
1489
|
//TODO what if there is no name ?? Concepts may be cached (e.g. via TCS import)
|
|
1490
|
TaxonName synonymName = synonym.getName();
|
|
1491
|
TaxonName fromTaxonName = oldTaxon.getName();
|
|
1492
|
//set default relationship type
|
|
1493
|
if (newSynonymType == null){
|
|
1494
|
newSynonymType = SynonymType.HETEROTYPIC_SYNONYM_OF();
|
|
1495
|
}
|
|
1496
|
boolean newRelTypeIsHomotypic = newSynonymType.equals(SynonymType.HOMOTYPIC_SYNONYM_OF());
|
|
1497
|
|
|
1498
|
HomotypicalGroup homotypicGroup = synonymName.getHomotypicalGroup();
|
|
1499
|
int hgSize = homotypicGroup.getTypifiedNames().size();
|
|
1500
|
boolean isSingleInGroup = !(hgSize > 1);
|
|
1501
|
|
|
1502
|
if (! isSingleInGroup){
|
|
1503
|
boolean isHomotypicToAccepted = synonymName.isHomotypic(fromTaxonName);
|
|
1504
|
boolean hasHomotypicSynonymRelatives = isHomotypicToAccepted ? hgSize > 2 : hgSize > 1;
|
|
1505
|
if (isHomotypicToAccepted){
|
|
1506
|
String message = "Synonym is in homotypic group with accepted taxon%s. First remove synonym from homotypic group of accepted taxon before moving to other taxon.";
|
|
1507
|
String homotypicRelatives = hasHomotypicSynonymRelatives ? " and other synonym(s)":"";
|
|
1508
|
message = String.format(message, homotypicRelatives);
|
|
1509
|
throw new HomotypicalGroupChangeException(message);
|
|
1510
|
}
|
|
1511
|
if (! moveHomotypicGroup){
|
|
1512
|
String message = "Synonym is in homotypic group with other synonym(s). Either move complete homotypic group or remove synonym from homotypic group prior to moving to other taxon.";
|
|
1513
|
throw new HomotypicalGroupChangeException(message);
|
|
1514
|
}
|
|
1515
|
}else{
|
|
1516
|
moveHomotypicGroup = true; //single synonym always allows to moveCompleteGroup
|
|
1517
|
}
|
|
1518
|
// Assert.assertTrue("Synonym can only be moved with complete homotypic group", moveHomotypicGroup);
|
|
1519
|
|
|
1520
|
UpdateResult result = new UpdateResult();
|
|
1521
|
//move all synonyms to new taxon
|
|
1522
|
List<Synonym> homotypicSynonyms = oldTaxon.getSynonymsInGroup(homotypicGroup);
|
|
1523
|
Reference newSecundum = referenceService.load(newSecundumUuid);
|
|
1524
|
for (Synonym synRelation: homotypicSynonyms){
|
|
1525
|
|
|
1526
|
newTaxon = HibernateProxyHelper.deproxy(newTaxon, Taxon.class);
|
|
1527
|
oldTaxon = HibernateProxyHelper.deproxy(oldTaxon, Taxon.class);
|
|
1528
|
oldTaxon.removeSynonym(synRelation, false);
|
|
1529
|
newTaxon.addSynonym(synRelation, newSynonymType);
|
|
1530
|
|
|
1531
|
if (newSecundum != null || !keepSecundumIfUndefined){
|
|
1532
|
synRelation.setSec(newSecundum);
|
|
1533
|
}
|
|
1534
|
if (newSecundumDetail != null || !keepSecundumIfUndefined){
|
|
1535
|
synRelation.setSecMicroReference(newSecundumDetail);
|
|
1536
|
}
|
|
1537
|
|
|
1538
|
//set result //why is this needed? Seems wrong to me (AM 10.10.2016)
|
|
1539
|
if (!synRelation.equals(oldSynonym)){
|
|
1540
|
result.setError();
|
|
1541
|
}
|
|
1542
|
}
|
|
1543
|
|
|
1544
|
result.addUpdatedObject(oldTaxon);
|
|
1545
|
result.addUpdatedObject(newTaxon);
|
|
1546
|
saveOrUpdate(oldTaxon);
|
|
1547
|
saveOrUpdate(newTaxon);
|
|
1548
|
|
|
1549
|
return result;
|
|
1550
|
}
|
|
1551
|
|
|
1552
|
@Override
|
|
1553
|
public <T extends TaxonBase>List<UuidAndTitleCache<T>> getUuidAndTitleCache(Class<T> clazz, Integer limit, String pattern) {
|
|
1554
|
|
|
1555
|
return dao.getUuidAndTitleCache(clazz, limit, pattern);
|
|
1556
|
}
|
|
1557
|
|
|
1558
|
@Override
|
|
1559
|
public Pager<SearchResult<TaxonBase>> findByFullText(
|
|
1560
|
Class<? extends TaxonBase> clazz, String queryString,
|
|
1561
|
Classification classification, TaxonNode subtree, boolean includeUnpublished, List<Language> languages,
|
|
1562
|
boolean highlightFragments, Integer pageSize, Integer pageNumber,
|
|
1563
|
List<OrderHint> orderHints, List<String> propertyPaths) throws IOException, LuceneParseException {
|
|
1564
|
|
|
1565
|
LuceneSearch luceneSearch = prepareFindByFullTextSearch(clazz, queryString, classification, subtree,
|
|
1566
|
null, includeUnpublished, languages, highlightFragments, null);
|
|
1567
|
|
|
1568
|
// --- execute search
|
|
1569
|
TopGroups<BytesRef> topDocsResultSet;
|
|
1570
|
try {
|
|
1571
|
topDocsResultSet = luceneSearch.executeSearch(pageSize, pageNumber);
|
|
1572
|
} catch (ParseException e) {
|
|
1573
|
LuceneParseException luceneParseException = new LuceneParseException(e.getMessage());
|
|
1574
|
luceneParseException.setStackTrace(e.getStackTrace());
|
|
1575
|
throw luceneParseException;
|
|
1576
|
}
|
|
1577
|
|
|
1578
|
Map<CdmBaseType, String> idFieldMap = new HashMap<>();
|
|
1579
|
idFieldMap.put(CdmBaseType.TAXON_BASE, "id");
|
|
1580
|
|
|
1581
|
// --- initialize taxa, thighlight matches ....
|
|
1582
|
ISearchResultBuilder searchResultBuilder = new SearchResultBuilder(luceneSearch, luceneSearch.getQuery());
|
|
1583
|
@SuppressWarnings("rawtypes")
|
|
1584
|
List<SearchResult<TaxonBase>> searchResults = searchResultBuilder.createResultSet(
|
|
1585
|
topDocsResultSet, luceneSearch.getHighlightFields(), dao, idFieldMap, propertyPaths);
|
|
1586
|
|
|
1587
|
long totalHits = topDocsResultSet != null ? Long.valueOf(topDocsResultSet.totalGroupCount) : 0;
|
|
1588
|
return new DefaultPagerImpl<>(pageNumber, totalHits, pageSize, searchResults);
|
|
1589
|
}
|
|
1590
|
|
|
1591
|
@Transactional(readOnly = true)
|
|
1592
|
@Override
|
|
1593
|
public <S extends TaxonBase> Pager<S> findByTitleWithRestrictions(Class<S> clazz, String queryString, MatchMode matchmode, List<Restriction<?>> restrictions, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
|
|
1594
|
long numberOfResults = dao.countByTitleWithRestrictions(clazz, queryString, matchmode, restrictions);
|
|
1595
|
|
|
1596
|
long numberOfResults_doubtful = dao.countByTitleWithRestrictions(clazz, "?".concat(queryString), matchmode, restrictions);
|
|
1597
|
List<S> results = new ArrayList<>();
|
|
1598
|
if(numberOfResults > 0 || numberOfResults_doubtful > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)
|
|
1599
|
|
|
1600
|
results = dao.findByTitleWithRestrictions(clazz, queryString, matchmode, restrictions, pageSize, pageNumber, orderHints, propertyPaths);
|
|
1601
|
results.addAll(dao.findByTitleWithRestrictions(clazz, "?".concat(queryString), matchmode, restrictions, pageSize, pageNumber, orderHints, propertyPaths));
|
|
1602
|
}
|
|
1603
|
Collections.sort(results, new TaxonComparator());
|
|
1604
|
return new DefaultPagerImpl<>(pageNumber, numberOfResults, pageSize, results);
|
|
1605
|
}
|
|
1606
|
|
|
1607
|
@Transactional(readOnly = true)
|
|
1608
|
@Override
|
|
1609
|
public <S extends TaxonBase> Pager<S> findByTitle(Class<S> clazz, String queryString,MatchMode matchmode, List<Criterion> criteria, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
|
|
1610
|
long numberOfResults = dao.countByTitle(clazz, queryString, matchmode, criteria);
|
|
1611
|
//check whether there are doubtful taxa matching
|
|
1612
|
long numberOfResults_doubtful = dao.countByTitle(clazz, "?".concat(queryString), matchmode, criteria);
|
|
1613
|
List<S> results = new ArrayList<>();
|
|
1614
|
if(numberOfResults > 0 || numberOfResults_doubtful > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)
|
|
1615
|
if (numberOfResults > 0){
|
|
1616
|
results = dao.findByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
|
|
1617
|
}else{
|
|
1618
|
results = new ArrayList<>();
|
|
1619
|
}
|
|
1620
|
if (numberOfResults_doubtful > 0){
|
|
1621
|
results.addAll(dao.findByTitle(clazz, "?".concat(queryString), matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths));
|
|
1622
|
}
|
|
1623
|
}
|
|
1624
|
Collections.sort(results, new TaxonComparator());
|
|
1625
|
return new DefaultPagerImpl<>(pageNumber, numberOfResults, pageSize, results);
|
|
1626
|
}
|
|
1627
|
|
|
1628
|
@Override
|
|
1629
|
public Pager<SearchResult<TaxonBase>> findByDistribution(List<NamedArea> areaFilter, List<PresenceAbsenceTerm> statusFilter,
|
|
1630
|
Classification classification, TaxonNode subtree,
|
|
1631
|
Integer pageSize, Integer pageNumber,
|
|
1632
|
List<OrderHint> orderHints, List<String> propertyPaths) throws IOException, LuceneParseException {
|
|
1633
|
|
|
1634
|
LuceneSearch luceneSearch = prepareByDistributionSearch(areaFilter, statusFilter, classification, subtree);
|
|
1635
|
|
|
1636
|
// --- execute search
|
|
1637
|
TopGroups<BytesRef> topDocsResultSet;
|
|
1638
|
try {
|
|
1639
|
topDocsResultSet = luceneSearch.executeSearch(pageSize, pageNumber);
|
|
1640
|
} catch (ParseException e) {
|
|
1641
|
LuceneParseException luceneParseException = new LuceneParseException(e.getMessage());
|
|
1642
|
luceneParseException.setStackTrace(e.getStackTrace());
|
|
1643
|
throw luceneParseException;
|
|
1644
|
}
|
|
1645
|
|
|
1646
|
Map<CdmBaseType, String> idFieldMap = new HashMap<>();
|
|
1647
|
idFieldMap.put(CdmBaseType.TAXON_BASE, "id");
|
|
1648
|
|
|
1649
|
// --- initialize taxa, thighlight matches ....
|
|
1650
|
ISearchResultBuilder searchResultBuilder = new SearchResultBuilder(luceneSearch, luceneSearch.getQuery());
|
|
1651
|
List<SearchResult<TaxonBase>> searchResults = searchResultBuilder.createResultSet(
|
|
1652
|
topDocsResultSet, luceneSearch.getHighlightFields(), dao, idFieldMap, propertyPaths);
|
|
1653
|
|
|
1654
|
long totalHits = topDocsResultSet != null ? Long.valueOf(topDocsResultSet.totalGroupCount) : 0;
|
|
1655
|
return new DefaultPagerImpl<>(pageNumber, totalHits, pageSize, searchResults);
|
|
1656
|
}
|
|
1657
|
|
|
1658
|
/**
|
|
1659
|
* @param clazz
|
|
1660
|
* @param queryString
|
|
1661
|
* @param classification
|
|
1662
|
* @param includeUnpublished
|
|
1663
|
* @param languages
|
|
1664
|
* @param highlightFragments
|
|
1665
|
* @param sortFields TODO
|
|
1666
|
* @param directorySelectClass
|
|
1667
|
* @return
|
|
1668
|
*/
|
|
1669
|
protected LuceneSearch prepareFindByFullTextSearch(Class<? extends CdmBase> clazz, String queryString,
|
|
1670
|
Classification classification, TaxonNode subtree, String className, boolean includeUnpublished, List<Language> languages,
|
|
1671
|
boolean highlightFragments, SortField[] sortFields) {
|
|
1672
|
|
|
1673
|
Builder finalQueryBuilder = new Builder();
|
|
1674
|
Builder textQueryBuilder = new Builder();
|
|
1675
|
|
|
1676
|
LuceneSearch luceneSearch = new LuceneSearch(luceneIndexToolProvider, GroupByTaxonClassBridge.GROUPBY_TAXON_FIELD, TaxonBase.class);
|
|
1677
|
QueryFactory taxonBaseQueryFactory = luceneIndexToolProvider.newQueryFactoryFor(TaxonBase.class);
|
|
1678
|
|
|
1679
|
if(sortFields == null){
|
|
1680
|
sortFields = new SortField[]{SortField.FIELD_SCORE, new SortField("titleCache__sort", SortField.Type.STRING, false)};
|
|
1681
|
}
|
|
1682
|
luceneSearch.setSortFields(sortFields);
|
|
1683
|
|
|
1684
|
// ---- search criteria
|
|
1685
|
luceneSearch.setCdmTypRestriction(clazz);
|
|
1686
|
|
|
1687
|
if(!StringUtils.isEmpty(queryString) && !queryString.equals("*") && !queryString.equals("?") ) {
|
|
1688
|
textQueryBuilder.add(taxonBaseQueryFactory.newTermQuery("titleCache", queryString), Occur.SHOULD);
|
|
1689
|
textQueryBuilder.add(taxonBaseQueryFactory.newDefinedTermQuery("name.rank", queryString, languages), Occur.SHOULD);
|
|
1690
|
}
|
|
1691
|
if(className != null){
|
|
1692
|
textQueryBuilder.add(taxonBaseQueryFactory.newTermQuery("classInfo.name", className, false), Occur.MUST);
|
|
1693
|
}
|
|
1694
|
|
|
1695
|
BooleanQuery textQuery = textQueryBuilder.build();
|
|
1696
|
if(textQuery.clauses().size() > 0) {
|
|
1697
|
finalQueryBuilder.add(textQuery, Occur.MUST);
|
|
1698
|
}
|
|
1699
|
|
|
1700
|
if(classification != null){
|
|
1701
|
finalQueryBuilder.add(taxonBaseQueryFactory.newEntityIdQuery(AcceptedTaxonBridge.DOC_KEY_CLASSIFICATION_ID, classification), Occur.MUST);
|
|
1702
|
}
|
|
1703
|
if(subtree != null){
|
|
1704
|
finalQueryBuilder.add(taxonBaseQueryFactory.newTermQuery(AcceptedTaxonBridge.DOC_KEY_TREEINDEX, subtree.treeIndexWc(), true), Occur.MUST);
|
|
1705
|
}
|
|
1706
|
if(!includeUnpublished) {
|
|
1707
|
String accPublishParam = TaxonBase.ACC_TAXON_BRIDGE_PREFIX + AcceptedTaxonBridge.DOC_KEY_PUBLISH_SUFFIX;
|
|
1708
|
finalQueryBuilder.add(taxonBaseQueryFactory.newBooleanQuery(accPublishParam, true), Occur.MUST);
|
|
1709
|
finalQueryBuilder.add(taxonBaseQueryFactory.newBooleanQuery("publish", true), Occur.MUST);
|
|
1710
|
}
|
|
1711
|
|
|
1712
|
luceneSearch.setQuery(finalQueryBuilder.build());
|
|
1713
|
|
|
1714
|
if(highlightFragments){
|
|
1715
|
luceneSearch.setHighlightFields(taxonBaseQueryFactory.getTextFieldNamesAsArray());
|
|
1716
|
}
|
|
1717
|
return luceneSearch;
|
|
1718
|
}
|
|
1719
|
|
|
1720
|
/**
|
|
1721
|
* Uses org.apache.lucene.search.join.JoinUtil for query time joining, alternatively
|
|
1722
|
* the BlockJoinQuery could be used. The latter might be more memory save but has the
|
|
1723
|
* drawback of requiring to do the join an indexing time.
|
|
1724
|
* see http://dev.e-taxonomy.eu/trac/wiki/LuceneNotes#JoinsinLucene for more information on this.
|
|
1725
|
*
|
|
1726
|
* Joins TaxonRelationShip with Taxon depending on the direction of the given edge:
|
|
1727
|
* <ul>
|
|
1728
|
* <li>direct, everted: {@link Direction.relatedTo}: TaxonRelationShip.relatedTo.id --> Taxon.id </li>
|
|
1729
|
* <li>inverse: {@link Direction.relatedFrom}: TaxonRelationShip.relatedFrom.id --> Taxon.id </li>
|
|
1730
|
* <ul>
|
|
1731
|
* @param queryString
|
|
1732
|
* @param classification
|
|
1733
|
* @param languages
|
|
1734
|
* @param highlightFragments
|
|
1735
|
* @param sortFields TODO
|
|
1736
|
*
|
|
1737
|
* @return
|
|
1738
|
* @throws IOException
|
|
1739
|
*/
|
|
1740
|
protected LuceneSearch prepareFindByTaxonRelationFullTextSearch(TaxonRelationshipEdge edge, String queryString,
|
|
1741
|
Classification classification, TaxonNode subtree, boolean includeUnpublished, List<Language> languages,
|
|
1742
|
boolean highlightFragments, SortField[] sortFields) throws IOException {
|
|
1743
|
|
|
1744
|
String fromField;
|
|
1745
|
String queryTermField;
|
|
1746
|
String toField = "id"; // TaxonBase.uuid
|
|
1747
|
String publishField;
|
|
1748
|
String publishFieldInvers;
|
|
1749
|
|
|
1750
|
if(edge.isBidirectional()){
|
|
1751
|
throw new RuntimeException("Bidirectional joining not supported!");
|
|
1752
|
}
|
|
1753
|
if(edge.isEvers()){
|
|
1754
|
fromField = "relatedFrom.id";
|
|
1755
|
queryTermField = "relatedFrom.titleCache";
|
|
1756
|
publishField = "relatedFrom.publish";
|
|
1757
|
publishFieldInvers = "relatedTo.publish";
|
|
1758
|
} else if(edge.isInvers()) {
|
|
1759
|
fromField = "relatedTo.id";
|
|
1760
|
queryTermField = "relatedTo.titleCache";
|
|
1761
|
publishField = "relatedTo.publish";
|
|
1762
|
publishFieldInvers = "relatedFrom.publish";
|
|
1763
|
} else {
|
|
1764
|
throw new RuntimeException("Invalid direction: " + edge.getDirections());
|
|
1765
|
}
|
|
1766
|
|
|
1767
|
Builder finalQueryBuilder = new Builder();
|
|
1768
|
|
|
1769
|
LuceneSearch luceneSearch = new LuceneSearch(luceneIndexToolProvider, GroupByTaxonClassBridge.GROUPBY_TAXON_FIELD, TaxonBase.class);
|
|
1770
|
QueryFactory taxonBaseQueryFactory = luceneIndexToolProvider.newQueryFactoryFor(TaxonBase.class);
|
|
1771
|
|
|
1772
|
Builder joinFromQueryBuilder = new Builder();
|
|
1773
|
if(!StringUtils.isEmpty(queryString)){
|
|
1774
|
joinFromQueryBuilder.add(taxonBaseQueryFactory.newTermQuery(queryTermField, queryString), Occur.MUST);
|
|
1775
|
}
|
|
1776
|
joinFromQueryBuilder.add(taxonBaseQueryFactory.newEntityIdsQuery("type.id", edge.getRelationshipTypes()), Occur.MUST);
|
|
1777
|
if(!includeUnpublished){
|
|
1778
|
joinFromQueryBuilder.add(taxonBaseQueryFactory.newBooleanQuery(publishField, true), Occur.MUST);
|
|
1779
|
joinFromQueryBuilder.add(taxonBaseQueryFactory.newBooleanQuery(publishFieldInvers, true), Occur.MUST);
|
|
1780
|
}
|
|
1781
|
|
|
1782
|
Query joinQuery = taxonBaseQueryFactory.newJoinQuery(TaxonRelationship.class, fromField, false, joinFromQueryBuilder.build(), toField, null, ScoreMode.Max);
|
|
1783
|
|
|
1784
|
if(sortFields == null){
|
|
1785
|
sortFields = new SortField[]{SortField.FIELD_SCORE, new SortField("titleCache__sort", SortField.Type.STRING, false)};
|
|
1786
|
}
|
|
1787
|
luceneSearch.setSortFields(sortFields);
|
|
1788
|
|
|
1789
|
finalQueryBuilder.add(joinQuery, Occur.MUST);
|
|
1790
|
|
|
1791
|
if(classification != null){
|
|
1792
|
finalQueryBuilder.add(taxonBaseQueryFactory.newEntityIdQuery(AcceptedTaxonBridge.DOC_KEY_CLASSIFICATION_ID, classification), Occur.MUST);
|
|
1793
|
}
|
|
1794
|
if(subtree != null){
|
|
1795
|
finalQueryBuilder.add(taxonBaseQueryFactory.newTermQuery(AcceptedTaxonBridge.DOC_KEY_TREEINDEX, subtree.treeIndexWc(), true), Occur.MUST);
|
|
1796
|
}
|
|
1797
|
|
|
1798
|
luceneSearch.setQuery(finalQueryBuilder.build());
|
|
1799
|
|
|
1800
|
if(highlightFragments){
|
|
1801
|
luceneSearch.setHighlightFields(taxonBaseQueryFactory.getTextFieldNamesAsArray());
|
|
1802
|
}
|
|
1803
|
return luceneSearch;
|
|
1804
|
}
|
|
1805
|
|
|
1806
|
@Override
|
|
1807
|
public Pager<SearchResult<TaxonBase>> findTaxaAndNamesByFullText(
|
|
1808
|
EnumSet<TaxaAndNamesSearchMode> searchModes, String queryString,
|
|
1809
|
Classification classification, TaxonNode subtree,
|
|
1810
|
Set<NamedArea> namedAreas, Set<PresenceAbsenceTerm> distributionStatus, List<Language> languages,
|
|
1811
|
boolean highlightFragments, Integer pageSize,
|
|
1812
|
Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths)
|
|
1813
|
throws IOException, LuceneParseException, LuceneMultiSearchException {
|
|
1814
|
|
|
1815
|
// FIXME: allow taxonomic ordering
|
|
1816
|
// hql equivalent: order by t.name.genusOrUninomial, case when t.name.specificEpithet like '\"%\"' then 1 else 0 end, t.name.specificEpithet, t.name.rank desc, t.name.nameCache";
|
|
1817
|
// this require building a special sort column by a special classBridge
|
|
1818
|
if(highlightFragments){
|
|
1819
|
logger.warn("findTaxaAndNamesByFullText() : fragment highlighting is " +
|
|
1820
|
"currently not fully supported by this method and thus " +
|
|
1821
|
"may not work with common names and misapplied names.");
|
|
1822
|
}
|
|
1823
|
|
|
1824
|
// convert sets to lists
|
|
1825
|
List<NamedArea> namedAreaList = null;
|
|
1826
|
List<PresenceAbsenceTerm> distributionStatusList = null;
|
|
1827
|
if(namedAreas != null){
|
|
1828
|
namedAreaList = new ArrayList<>(namedAreas.size());
|
|
1829
|
namedAreaList.addAll(namedAreas);
|
|
1830
|
}
|
|
1831
|
if(distributionStatus != null){
|
|
1832
|
distributionStatusList = new ArrayList<>(distributionStatus.size());
|
|
1833
|
distributionStatusList.addAll(distributionStatus);
|
|
1834
|
}
|
|
1835
|
|
|
1836
|
// set default if parameter is null
|
|
1837
|
if(searchModes == null){
|
|
1838
|
searchModes = EnumSet.of(TaxaAndNamesSearchMode.doTaxa);
|
|
1839
|
}
|
|
1840
|
|
|
1841
|
// set sort order and thus override any sort orders which may have been
|
|
1842
|
// defined by prepare*Search methods
|
|
1843
|
if(orderHints == null){
|
|
1844
|
orderHints = OrderHint.NOMENCLATURAL_SORT_ORDER.asList();
|
|
1845
|
}
|
|
1846
|
SortField[] sortFields = new SortField[orderHints.size()];
|
|
1847
|
int i = 0;
|
|
1848
|
for(OrderHint oh : orderHints){
|
|
1849
|
sortFields[i++] = oh.toSortField();
|
|
1850
|
}
|
|
1851
|
// SortField[] sortFields = new SortField[]{SortField.FIELD_SCORE, new SortField("id", SortField.STRING, false)};
|
|
1852
|
// SortField[] sortFields = new SortField[]{new SortField(NomenclaturalSortOrderBrigde.NAME_SORT_FIELD_NAME, SortField.STRING, false)};
|
|
1853
|
|
|
1854
|
boolean addDistributionFilter = namedAreas != null && namedAreas.size() > 0;
|
|
1855
|
|
|
1856
|
List<LuceneSearch> luceneSearches = new ArrayList<>();
|
|
1857
|
Map<CdmBaseType, String> idFieldMap = new HashMap<>();
|
|
1858
|
|
|
1859
|
/*
|
|
1860
|
======== filtering by distribution , HOWTO ========
|
|
1861
|
|
|
1862
|
- http://www.javaranch.com/journal/2009/02/filtering-a-lucene-search.html
|
|
1863
|
- http://stackoverflow.com/questions/17709256/lucene-solr-using-complex-filters -> QueryWrapperFilter
|
|
1864
|
add Filter to search as http://lucene.apache.org/core/3_6_0/api/all/org/apache/lucene/search/Filter.html
|
|
1865
|
which will be put into a FilteredQuersy in the end ?
|
|
1866
|
|
|
1867
|
|
|
1868
|
3. how does it work in spatial?
|
|
1869
|
see
|
|
1870
|
- http://www.nsshutdown.com/projects/lucene/whitepaper/locallucene_v2.html
|
|
1871
|
- http://www.infoq.com/articles/LuceneSpatialSupport
|
|
1872
|
- http://www.mhaller.de/archives/156-Spatial-search-with-Lucene.html
|
|
1873
|
------------------------------------------------------------------------
|
|
1874
|
|
|
1875
|
filter strategies:
|
|
1876
|
A) use a separate distribution filter per index sub-query/search:
|
|
1877
|
- byTaxonSyonym (query TaxaonBase):
|
|
1878
|
use a join area filter (Distribution -> TaxonBase)
|
|
1879
|
- byCommonName (query DescriptionElementBase): use an area filter on
|
|
1880
|
DescriptionElementBase !!! PROBLEM !!!
|
|
1881
|
This cannot work since the distributions are different entities than the
|
|
1882
|
common names and thus these are different lucene documents.
|
|
1883
|
- byMisaplliedNames (join query TaxonRelationship -> TaxonBase):
|
|
1884
|
use a join area filter (Distribution -> TaxonBase)
|
|
1885
|
|
|
1886
|
B) use a common distribution filter for all index sub-query/searches:
|
|
1887
|
- use a common join area filter (Distribution -> TaxonBase)
|
|
1888
|
- also implement the byCommonName as join query (CommonName -> TaxonBase)
|
|
1889
|
PROBLEM in this case: we are losing the fragment highlighting for the
|
|
1890
|
common names, since the returned documents are always TaxonBases
|
|
1891
|
*/
|
|
1892
|
|
|
1893
|
/* The QueryFactory for creating filter queries on Distributions should
|
|
1894
|
* The query factory used for the common names query cannot be reused
|
|
1895
|
* for this case, since we want to only record the text fields which are
|
|
1896
|
* actually used in the primary query
|
|
1897
|
*/
|
|
1898
|
QueryFactory distributionFilterQueryFactory = luceneIndexToolProvider.newQueryFactoryFor(Distribution.class);
|
|
1899
|
|
|
1900
|
Builder multiIndexByAreaFilterBuilder = new Builder();
|
|
1901
|
boolean includeUnpublished = searchModes.contains(TaxaAndNamesSearchMode.includeUnpublished);
|
|
1902
|
|
|
1903
|
// search for taxa or synonyms
|
|
1904
|
if(searchModes.contains(TaxaAndNamesSearchMode.doTaxa) || searchModes.contains(TaxaAndNamesSearchMode.doSynonyms) ) {
|
|
1905
|
@SuppressWarnings("rawtypes")
|
|
1906
|
Class<? extends TaxonBase> taxonBaseSubclass = TaxonBase.class;
|
|
1907
|
String className = null;
|
|
1908
|
if(searchModes.contains(TaxaAndNamesSearchMode.doTaxa) && !searchModes.contains(TaxaAndNamesSearchMode.doSynonyms)){
|
|
1909
|
taxonBaseSubclass = Taxon.class;
|
|
1910
|
} else if (!searchModes.contains(TaxaAndNamesSearchMode.doTaxa) && searchModes.contains(TaxaAndNamesSearchMode.doSynonyms)) {
|
|
1911
|
className = "eu.etaxonomy.cdm.model.taxon.Synonym";
|
|
1912
|
}
|
|
1913
|
luceneSearches.add(prepareFindByFullTextSearch(taxonBaseSubclass,
|
|
1914
|
queryString, classification, subtree, className,
|
|
1915
|
includeUnpublished, languages, highlightFragments, sortFields));
|
|
1916
|
idFieldMap.put(CdmBaseType.TAXON_BASE, "id");
|
|
1917
|
/* A) does not work!!!!
|
|
1918
|
if(addDistributionFilter){
|
|
1919
|
// in this case we need a filter which uses a join query
|
|
1920
|
// to get the TaxonBase documents for the DescriptionElementBase documents
|
|
1921
|
// which are matching the areas in question
|
|
1922
|
Query taxonAreaJoinQuery = createByDistributionJoinQuery(
|
|
1923
|
namedAreaList,
|
|
1924
|
distributionStatusList,
|
|
1925
|
distributionFilterQueryFactory
|
|
1926
|
);
|
|
1927
|
multiIndexByAreaFilter.add(new QueryWrapperFilter(taxonAreaJoinQuery), Occur.SHOULD);
|
|
1928
|
}
|
|
1929
|
*/
|
|
1930
|
if(addDistributionFilter && searchModes.contains(TaxaAndNamesSearchMode.doSynonyms)){
|
|
1931
|
// add additional area filter for synonyms
|
|
1932
|
String fromField = "inDescription.taxon.id"; // in DescriptionElementBase index
|
|
1933
|
String toField = "accTaxon" + AcceptedTaxonBridge.DOC_KEY_ID_SUFFIX; // id in TaxonBase index
|
|
1934
|
|
|
1935
|
//TODO replace by createByDistributionJoinQuery
|
|
1936
|
BooleanQuery byDistributionQuery = createByDistributionQuery(namedAreaList, distributionStatusList, distributionFilterQueryFactory);
|
|
1937
|
Query taxonAreaJoinQuery = distributionFilterQueryFactory.newJoinQuery(Distribution.class, fromField, true, byDistributionQuery, toField, Taxon.class, ScoreMode.None);
|
|
1938
|
multiIndexByAreaFilterBuilder.add(taxonAreaJoinQuery, Occur.SHOULD);
|
|
1939
|
|
|
1940
|
}
|
|
1941
|
}
|
|
1942
|
|
|
1943
|
// search by CommonTaxonName
|
|
1944
|
if(searchModes.contains(TaxaAndNamesSearchMode.doTaxaByCommonNames)) {
|
|
1945
|
// B)
|
|
1946
|
QueryFactory descriptionElementQueryFactory = luceneIndexToolProvider.newQueryFactoryFor(DescriptionElementBase.class);
|
|
1947
|
Query byCommonNameJoinQuery = descriptionElementQueryFactory.newJoinQuery(
|
|
1948
|
CommonTaxonName.class,
|
|
1949
|
"inDescription.taxon.id",
|
|
1950
|
true,
|
|
1951
|
QueryFactory.addTypeRestriction(
|
|
1952
|
createByDescriptionElementFullTextQuery(queryString, classification, subtree, null, languages, descriptionElementQueryFactory)
|
|
1953
|
, CommonTaxonName.class
|
|
1954
|
).build(), "id", null, ScoreMode.Max);
|
|
1955
|
if (logger.isDebugEnabled()){logger.debug("byCommonNameJoinQuery: " + byCommonNameJoinQuery.toString());}
|
|
1956
|
LuceneSearch byCommonNameSearch = new LuceneSearch(luceneIndexToolProvider,
|
|
1957
|
GroupByTaxonClassBridge.GROUPBY_TAXON_FIELD, Taxon.class);
|
|
1958
|
byCommonNameSearch.setCdmTypRestriction(Taxon.class);
|
|
1959
|
Builder builder = new BooleanQuery.Builder();
|
|
1960
|
builder.add(byCommonNameJoinQuery, Occur.MUST);
|
|
1961
|
if(!includeUnpublished) {
|
|
1962
|
QueryFactory taxonBaseQueryFactory = luceneIndexToolProvider.newQueryFactoryFor(TaxonBase.class);
|
|
1963
|
builder.add(taxonBaseQueryFactory.newBooleanQuery("publish", true), Occur.MUST);
|
|
1964
|
}
|
|
1965
|
byCommonNameSearch.setQuery(builder.build());
|
|
1966
|
byCommonNameSearch.setSortFields(sortFields);
|
|
1967
|
|
|
1968
|
idFieldMap.put(CdmBaseType.TAXON_BASE, "id");
|
|
1969
|
|
|
1970
|
luceneSearches.add(byCommonNameSearch);
|
|
1971
|
|
|
1972
|
/* A) does not work!!!!
|
|
1973
|
luceneSearches.add(
|
|
1974
|
prepareByDescriptionElementFullTextSearch(CommonTaxonName.class,
|
|
1975
|
queryString, classification, null, languages, highlightFragments)
|
|
1976
|
);
|
|
1977
|
idFieldMap.put(CdmBaseType.DESCRIPTION_ELEMENT, "inDescription.taxon.id");
|
|
1978
|
if(addDistributionFilter){
|
|
1979
|
// in this case we are able to use DescriptionElementBase documents
|
|
1980
|
// which are matching the areas in question directly
|
|
1981
|
BooleanQuery byDistributionQuery = createByDistributionQuery(
|
|
1982
|
namedAreaList,
|
|
1983
|
distributionStatusList,
|
|
1984
|
distributionFilterQueryFactory
|
|
1985
|
);
|
|
1986
|
multiIndexByAreaFilter.add(new QueryWrapperFilter(byDistributionQuery), Occur.SHOULD);
|
|
1987
|
} */
|
|
1988
|
}
|
|
1989
|
|
|
1990
|
|
|
1991
|
// search by misapplied names
|
|
1992
|
//TODO merge with pro parte synonym search once #7487 is fixed
|
|
1993
|
if(searchModes.contains(TaxaAndNamesSearchMode.doMisappliedNames) /*|| searchModes.contains(TaxaAndNamesSearchMode.doSynonyms) */) {
|
|
1994
|
// NOTE:
|
|
1995
|
// prepareFindByTaxonRelationFullTextSearch() is making use of JoinUtil.createJoinQuery()
|
|
1996
|
// which allows doing query time joins
|
|
1997
|
// finds the misapplied name (Taxon B) which is an misapplication for
|
|
1998
|
// a related Taxon A.
|
|
1999
|
//
|
|
2000
|
Set<TaxonRelationshipType> relTypes = new HashSet<>();
|
|
2001
|
if (searchModes.contains(TaxaAndNamesSearchMode.doMisappliedNames)){
|
|
2002
|
relTypes.addAll(TaxonRelationshipType.allMisappliedNameTypes());
|
|
2003
|
}
|
|
2004
|
// if (searchModes.contains(TaxaAndNamesSearchMode.doSynonyms)){
|
|
2005
|
// relTypes.addAll(TaxonRelationshipType.allSynonymTypes());
|
|
2006
|
// }
|
|
2007
|
|
|
2008
|
luceneSearches.add(prepareFindByTaxonRelationFullTextSearch(
|
|
2009
|
new TaxonRelationshipEdge(relTypes, Direction.relatedTo),
|
|
2010
|
queryString, classification, subtree, includeUnpublished, languages, highlightFragments, sortFields));
|
|
2011
|
idFieldMap.put(CdmBaseType.TAXON_BASE, "id");
|
|
2012
|
|
|
2013
|
if(addDistributionFilter){
|
|
2014
|
String fromField = "inDescription.taxon.id"; // in DescriptionElementBase index
|
|
2015
|
|
|
2016
|
/*
|
|
2017
|
* Here I was facing a weird and nasty bug which took me bugging be really for hours until I found this solution.
|
|
2018
|
* Maybe this is a bug in java itself.
|
|
2019
|
*
|
|
2020
|
* When the string toField is constructed by using the expression TaxonRelationshipType.MISAPPLIED_NAME_FOR().getUuid().toString()
|
|
2021
|
* directly:
|
|
2022
|
*
|
|
2023
|
* String toField = "relation." + TaxonRelationshipType.MISAPPLIED_NAME_FOR().getUuid().toString() +".to.id";
|
|
2024
|
*
|
|
2025
|
* The byDistributionQuery fails, however when the uuid is first stored in another string variable the query
|
|
2026
|
* will execute as expected:
|
|
2027
|
*
|
|
2028
|
* String misappliedNameForUuid = TaxonRelationshipType.MISAPPLIED_NAME_FOR().getUuid().toString();
|
|
2029
|
* String toField = "relation." + misappliedNameForUuid +".to.id";
|
|
2030
|
*
|
|
2031
|
* Comparing both strings by the String.equals method returns true, so both String are identical.
|
|
2032
|
*
|
|
2033
|
* The bug occurs when running eu.etaxonomy.cdm.api.service.TaxonServiceSearchTest in eclipse and in maven and seems to to be
|
|
2034
|
* dependent from a specific jvm (openjdk6 6b27-1.12.6-1ubuntu0.13.04.2, openjdk7 7u25-2.3.10-1ubuntu0.13.04.2, oracle jdk1.7.0_25 tested)
|
|
2035
|
* The bug is persistent after a reboot of the development computer.
|
|
2036
|
*/
|
|
2037
|
// String misappliedNameForUuid = TaxonRelationshipType.MISAPPLIED_NAME_FOR().getUuid().toString();
|
|
2038
|
// String toField = "relation." + misappliedNameForUuid +".to.id";
|
|
2039
|
String toField = "relation.1ed87175-59dd-437e-959e-0d71583d8417.to.id";
|
|
2040
|
// System.out.println("relation.1ed87175-59dd-437e-959e-0d71583d8417.to.id".equals("relation." + misappliedNameForUuid +".to.id") ? " > identical" : " > different");
|
|
2041
|
// System.out.println("relation.1ed87175-59dd-437e-959e-0d71583d8417.to.id".equals("relation." + TaxonRelationshipType.MISAPPLIED_NAME_FOR().getUuid().toString() +".to.id") ? " > identical" : " > different");
|
|
2042
|
|
|
2043
|
//TODO replace by createByDistributionJoinQuery
|
|
2044
|
BooleanQuery byDistributionQuery = createByDistributionQuery(namedAreaList, distributionStatusList, distributionFilterQueryFactory);
|
|
2045
|
Query taxonAreaJoinQuery = distributionFilterQueryFactory.newJoinQuery(Distribution.class,
|
|
2046
|
fromField, true, byDistributionQuery, toField, null, ScoreMode.None);
|
|
2047
|
|
|
2048
|
// debug code for bug described above
|
|
2049
|
//does not compile anymore since changing from lucene 3.6.2 to lucene 4.10+
|
|
2050
|
// DocIdSet filterMatchSet = filter.getDocIdSet(luceneIndexToolProvider.getIndexReaderFor(Taxon.class));
|
|
2051
|
// System.err.println(DocIdBitSetPrinter.docsAsString(filterMatchSet, 100));
|
|
2052
|
|
|
2053
|
multiIndexByAreaFilterBuilder.add(taxonAreaJoinQuery, Occur.SHOULD);
|
|
2054
|
}
|
|
2055
|
}
|
|
2056
|
|
|
2057
|
// search by pro parte synonyms
|
|
2058
|
if(searchModes.contains(TaxaAndNamesSearchMode.doSynonyms)) {
|
|
2059
|
//TODO merge with misapplied name search once #7487 is fixed
|
|
2060
|
Set<TaxonRelationshipType> relTypes = new HashSet<>();
|
|
2061
|
relTypes.addAll(TaxonRelationshipType.allSynonymTypes());
|
|
2062
|
|
|
2063
|
luceneSearches.add(prepareFindByTaxonRelationFullTextSearch(
|
|
2064
|
new TaxonRelationshipEdge(relTypes, Direction.relatedTo),
|
|
2065
|
queryString, classification, subtree, includeUnpublished, languages, highlightFragments, sortFields));
|
|
2066
|
idFieldMap.put(CdmBaseType.TAXON_BASE, "id");
|
|
2067
|
|
|
2068
|
if(addDistributionFilter){
|
|
2069
|
String fromField = "inDescription.taxon.id"; // in DescriptionElementBase index
|
|
2070
|
String toField = "relation.8a896603-0fa3-44c6-9cd7-df2d8792e577.to.id";
|
|
2071
|
BooleanQuery byDistributionQuery = createByDistributionQuery(namedAreaList, distributionStatusList, distributionFilterQueryFactory);
|
|
2072
|
Query taxonAreaJoinQuery = distributionFilterQueryFactory.newJoinQuery(Distribution.class,
|
|
2073
|
fromField, true, byDistributionQuery, toField, null, ScoreMode.None);
|
|
2074
|
multiIndexByAreaFilterBuilder.add(taxonAreaJoinQuery, Occur.SHOULD);
|
|
2075
|
}
|
|
2076
|
}//end pro parte synonyms
|
|
2077
|
|
|
2078
|
LuceneMultiSearch multiSearch = new LuceneMultiSearch(luceneIndexToolProvider,
|
|
2079
|
luceneSearches.toArray(new LuceneSearch[luceneSearches.size()]));
|
|
2080
|
|
|
2081
|
if(addDistributionFilter){
|
|
2082
|
|
|
2083
|
// B)
|
|
2084
|
// in this case we need a filter which uses a join query
|
|
2085
|
// to get the TaxonBase documents for the DescriptionElementBase documents
|
|
2086
|
// which are matching the areas in question
|
|
2087
|
//
|
|
2088
|
// for doTaxa, doByCommonName
|
|
2089
|
Query taxonAreaJoinQuery = createByDistributionJoinQuery(
|
|
2090
|
namedAreaList,
|
|
2091
|
distributionStatusList,
|
|
2092
|
distributionFilterQueryFactory,
|
|
2093
|
Taxon.class, true
|
|
2094
|
);
|
|
2095
|
multiIndexByAreaFilterBuilder.add(taxonAreaJoinQuery, Occur.SHOULD);
|
|
2096
|
}
|
|
2097
|
|
|
2098
|
if (addDistributionFilter){
|
|
2099
|
multiSearch.setFilter(multiIndexByAreaFilterBuilder.build());
|
|
2100
|
}
|
|
2101
|
|
|
2102
|
|
|
2103
|
// --- execute search
|
|
2104
|
TopGroups<BytesRef> topDocsResultSet;
|
|
2105
|
try {
|
|
2106
|
topDocsResultSet = multiSearch.executeSearch(pageSize, pageNumber);
|
|
2107
|
} catch (ParseException e) {
|
|
2108
|
LuceneParseException luceneParseException = new LuceneParseException(e.getMessage());
|
|
2109
|
luceneParseException.setStackTrace(e.getStackTrace());
|
|
2110
|
throw luceneParseException;
|
|
2111
|
}
|
|
2112
|
|
|
2113
|
// --- initialize taxa, highlight matches ....
|
|
2114
|
ISearchResultBuilder searchResultBuilder = new SearchResultBuilder(multiSearch, multiSearch.getQuery());
|
|
2115
|
|
|
2116
|
|
|
2117
|
List<SearchResult<TaxonBase>> searchResults = searchResultBuilder.createResultSet(
|
|
2118
|
topDocsResultSet, multiSearch.getHighlightFields(), dao, idFieldMap, propertyPaths);
|
|
2119
|
|
|
2120
|
long totalHits = (topDocsResultSet != null) ? Long.valueOf(topDocsResultSet.totalGroupCount) : 0;
|
|
2121
|
return new DefaultPagerImpl<>(pageNumber, totalHits, pageSize, searchResults);
|
|
2122
|
}
|
|
2123
|
|
|
2124
|
/**
|
|
2125
|
* @param namedAreaList at least one area must be in the list
|
|
2126
|
* @param distributionStatusList optional
|
|
2127
|
* @param toType toType
|
|
2128
|
* Optional parameter. Only used for debugging to print the toType documents
|
|
2129
|
* @param asFilter TODO
|
|
2130
|
* @return
|
|
2131
|
* @throws IOException
|
|
2132
|
*/
|
|
2133
|
protected Query createByDistributionJoinQuery(
|
|
2134
|
List<NamedArea> namedAreaList,
|
|
2135
|
List<PresenceAbsenceTerm> distributionStatusList,
|
|
2136
|
QueryFactory queryFactory, Class<? extends CdmBase> toType, boolean asFilter
|
|
2137
|
) throws IOException {
|
|
2138
|
|
|
2139
|
String fromField = "inDescription.taxon.id"; // in DescriptionElementBase index
|
|
2140
|
String toField = "id"; // id in toType usually this is the TaxonBase index
|
|
2141
|
|
|
2142
|
BooleanQuery byDistributionQuery = createByDistributionQuery(namedAreaList, distributionStatusList, queryFactory);
|
|
2143
|
|
|
2144
|
ScoreMode scoreMode = asFilter ? ScoreMode.None : ScoreMode.Max;
|
|
2145
|
|
|
2146
|
Query taxonAreaJoinQuery = queryFactory.newJoinQuery(Distribution.class, fromField, false, byDistributionQuery, toField, toType, scoreMode);
|
|
2147
|
|
|
2148
|
return taxonAreaJoinQuery;
|
|
2149
|
}
|
|
2150
|
|
|
2151
|
/**
|
|
2152
|
* @param namedAreaList
|
|
2153
|
* @param distributionStatusList
|
|
2154
|
* @param queryFactory
|
|
2155
|
* @return
|
|
2156
|
*/
|
|
2157
|
private BooleanQuery createByDistributionQuery(List<NamedArea> namedAreaList,
|
|
2158
|
List<PresenceAbsenceTerm> distributionStatusList, QueryFactory queryFactory) {
|
|
2159
|
Builder areaQueryBuilder = new Builder();
|
|
2160
|
// area field from Distribution
|
|
2161
|
areaQueryBuilder.add(queryFactory.newEntityIdsQuery("area.id", namedAreaList), Occur.MUST);
|
|
2162
|
|
|
2163
|
// status field from Distribution
|
|
2164
|
if(distributionStatusList != null && distributionStatusList.size() > 0){
|
|
2165
|
areaQueryBuilder.add(queryFactory.newEntityIdsQuery("status.id", distributionStatusList), Occur.MUST);
|
|
2166
|
}
|
|
2167
|
|
|
2168
|
BooleanQuery areaQuery = areaQueryBuilder.build();
|
|
2169
|
logger.debug("createByDistributionQuery() query: " + areaQuery.toString());
|
|
2170
|
return areaQuery;
|
|
2171
|
}
|
|
2172
|
|
|
2173
|
/**
|
|
2174
|
* This method has been primarily created for testing the area join query but might
|
|
2175
|
* also be useful in other situations
|
|
2176
|
*
|
|
2177
|
* @param namedAreaList
|
|
2178
|
* @param distributionStatusList
|
|
2179
|
* @param classification
|
|
2180
|
* @param highlightFragments
|
|
2181
|
* @return
|
|
2182
|
* @throws IOException
|
|
2183
|
*/
|
|
2184
|
protected LuceneSearch prepareByDistributionSearch(
|
|
2185
|
List<NamedArea> namedAreaList, List<PresenceAbsenceTerm> distributionStatusList,
|
|
2186
|
Classification classification, TaxonNode subtree) throws IOException {
|
|
2187
|
|
|
2188
|
Builder finalQueryBuilder = new Builder();
|
|
2189
|
|
|
2190
|
LuceneSearch luceneSearch = new LuceneSearch(luceneIndexToolProvider, GroupByTaxonClassBridge.GROUPBY_TAXON_FIELD, Taxon.class);
|
|
2191
|
|
|
2192
|
// FIXME is this query factory using the wrong type?
|
|
2193
|
QueryFactory taxonQueryFactory = luceneIndexToolProvider.newQueryFactoryFor(Taxon.class);
|
|
2194
|
|
|
2195
|
SortField[] sortFields = new SortField[]{SortField.FIELD_SCORE, new SortField("titleCache__sort", SortField.Type.STRING, false)};
|
|
2196
|
luceneSearch.setSortFields(sortFields);
|
|
2197
|
|
|
2198
|
|
|
2199
|
Query byAreaQuery = createByDistributionJoinQuery(namedAreaList, distributionStatusList, taxonQueryFactory, null, false);
|
|
2200
|
|
|
2201
|
finalQueryBuilder.add(byAreaQuery, Occur.MUST);
|
|
2202
|
|
|
2203
|
if(classification != null){
|
|
2204
|
finalQueryBuilder.add(taxonQueryFactory.newEntityIdQuery(AcceptedTaxonBridge.DOC_KEY_CLASSIFICATION_ID, classification), Occur.MUST);
|
|
2205
|
}
|
|
2206
|
if(subtree != null){
|
|
2207
|
finalQueryBuilder.add(taxonQueryFactory.newTermQuery(AcceptedTaxonBridge.DOC_KEY_TREEINDEX, subtree.treeIndexWc(), true), Occur.MUST);
|
|
2208
|
}
|
|
2209
|
BooleanQuery finalQuery = finalQueryBuilder.build();
|
|
2210
|
logger.info("prepareByAreaSearch() query: " + finalQuery.toString());
|
|
2211
|
luceneSearch.setQuery(finalQuery);
|
|
2212
|
|
|
2213
|
return luceneSearch;
|
|
2214
|
}
|
|
2215
|
|
|
2216
|
@Override
|
|
2217
|
public Pager<SearchResult<TaxonBase>> findByDescriptionElementFullText(
|
|
2218
|
Class<? extends DescriptionElementBase> clazz, String queryString,
|
|
2219
|
Classification classification, TaxonNode subtree, List<Feature> features, List<Language> languages,
|
|
2220
|
boolean highlightFragments, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) throws IOException, LuceneParseException {
|
|
2221
|
|
|
2222
|
LuceneSearch luceneSearch = prepareByDescriptionElementFullTextSearch(clazz, queryString, classification, subtree, features, languages, highlightFragments);
|
|
2223
|
|
|
2224
|
// --- execute search
|
|
2225
|
TopGroups<BytesRef> topDocsResultSet;
|
|
2226
|
try {
|
|
2227
|
topDocsResultSet = luceneSearch.executeSearch(pageSize, pageNumber);
|
|
2228
|
} catch (ParseException e) {
|
|
2229
|
LuceneParseException luceneParseException = new LuceneParseException(e.getMessage());
|
|
2230
|
luceneParseException.setStackTrace(e.getStackTrace());
|
|
2231
|
throw luceneParseException;
|
|
2232
|
}
|
|
2233
|
|
|
2234
|
Map<CdmBaseType, String> idFieldMap = new HashMap<>();
|
|
2235
|
idFieldMap.put(CdmBaseType.DESCRIPTION_ELEMENT, "inDescription.taxon.id");
|
|
2236
|
|
|
2237
|
// --- initialize taxa, highlight matches ....
|
|
2238
|
ISearchResultBuilder searchResultBuilder = new SearchResultBuilder(luceneSearch, luceneSearch.getQuery());
|
|
2239
|
@SuppressWarnings("rawtypes")
|
|
2240
|
List<SearchResult<TaxonBase>> searchResults = searchResultBuilder.createResultSet(
|
|
2241
|
topDocsResultSet, luceneSearch.getHighlightFields(), dao, idFieldMap, propertyPaths);
|
|
2242
|
|
|
2243
|
int totalHits = topDocsResultSet != null ? topDocsResultSet.totalGroupCount : 0;
|
|
2244
|
return new DefaultPagerImpl<>(pageNumber, Long.valueOf(totalHits), pageSize, searchResults);
|
|
2245
|
}
|
|
2246
|
|
|
2247
|
@Override
|
|
2248
|
public Pager<SearchResult<TaxonBase>> findByEverythingFullText(String queryString,
|
|
2249
|
Classification classification, TaxonNode subtree, boolean includeUnpublished, List<Language> languages, boolean highlightFragments,
|
|
2250
|
Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) throws IOException, LuceneParseException, LuceneMultiSearchException {
|
|
2251
|
|
|
2252
|
LuceneSearch luceneSearchByDescriptionElement = prepareByDescriptionElementFullTextSearch(null, queryString,
|
|
2253
|
classification, subtree,
|
|
2254
|
null, languages, highlightFragments);
|
|
2255
|
LuceneSearch luceneSearchByTaxonBase = prepareFindByFullTextSearch(null, queryString, classification, subtree, null,
|
|
2256
|
includeUnpublished, languages, highlightFragments, null);
|
|
2257
|
|
|
2258
|
LuceneMultiSearch multiSearch = new LuceneMultiSearch(luceneIndexToolProvider, luceneSearchByDescriptionElement, luceneSearchByTaxonBase);
|
|
2259
|
|
|
2260
|
// --- execute search
|
|
2261
|
TopGroups<BytesRef> topDocsResultSet;
|
|
2262
|
try {
|
|
2263
|
topDocsResultSet = multiSearch.executeSearch(pageSize, pageNumber);
|
|
2264
|
} catch (ParseException e) {
|
|
2265
|
LuceneParseException luceneParseException = new LuceneParseException(e.getMessage());
|
|
2266
|
luceneParseException.setStackTrace(e.getStackTrace());
|
|
2267
|
throw luceneParseException;
|
|
2268
|
}
|
|
2269
|
|
|
2270
|
// --- initialize taxa, highlight matches ....
|
|
2271
|
ISearchResultBuilder searchResultBuilder = new SearchResultBuilder(multiSearch, multiSearch.getQuery());
|
|
2272
|
|
|
2273
|
Map<CdmBaseType, String> idFieldMap = new HashMap<>();
|
|
2274
|
idFieldMap.put(CdmBaseType.TAXON_BASE, "id");
|
|
2275
|
idFieldMap.put(CdmBaseType.DESCRIPTION_ELEMENT, "inDescription.taxon.id");
|
|
2276
|
|
|
2277
|
List<SearchResult<TaxonBase>> searchResults = searchResultBuilder.createResultSet(
|
|
2278
|
topDocsResultSet, multiSearch.getHighlightFields(), dao, idFieldMap, propertyPaths);
|
|
2279
|
|
|
2280
|
int totalHits = topDocsResultSet != null ? topDocsResultSet.totalGroupCount : 0;
|
|
2281
|
return new DefaultPagerImpl<>(pageNumber, Long.valueOf(totalHits), pageSize, searchResults);
|
|
2282
|
}
|
|
2283
|
|
|
2284
|
/**
|
|
2285
|
* @param clazz
|
|
2286
|
* @param queryString
|
|
2287
|
* @param classification
|
|
2288
|
* @param features
|
|
2289
|
* @param languages
|
|
2290
|
* @param highlightFragments
|
|
2291
|
* @param directorySelectClass
|
|
2292
|
* @return
|
|
2293
|
*/
|
|
2294
|
protected LuceneSearch prepareByDescriptionElementFullTextSearch(Class<? extends CdmBase> clazz,
|
|
2295
|
String queryString, Classification classification, TaxonNode subtree, List<Feature> features,
|
|
2296
|
List<Language> languages, boolean highlightFragments) {
|
|
2297
|
|
|
2298
|
LuceneSearch luceneSearch = new LuceneSearch(luceneIndexToolProvider, GroupByTaxonClassBridge.GROUPBY_TAXON_FIELD, DescriptionElementBase.class);
|
|
2299
|
QueryFactory descriptionElementQueryFactory = luceneIndexToolProvider.newQueryFactoryFor(DescriptionElementBase.class);
|
|
2300
|
|
|
2301
|
SortField[] sortFields = new SortField[]{SortField.FIELD_SCORE, new SortField("inDescription.taxon.titleCache__sort", SortField.Type.STRING, false)};
|
|
2302
|
|
|
2303
|
BooleanQuery finalQuery = createByDescriptionElementFullTextQuery(queryString, classification, subtree, features,
|
|
2304
|
languages, descriptionElementQueryFactory);
|
|
2305
|
|
|
2306
|
luceneSearch.setSortFields(sortFields);
|
|
2307
|
luceneSearch.setCdmTypRestriction(clazz);
|
|
2308
|
luceneSearch.setQuery(finalQuery);
|
|
2309
|
if(highlightFragments){
|
|
2310
|
luceneSearch.setHighlightFields(descriptionElementQueryFactory.getTextFieldNamesAsArray());
|
|
2311
|
}
|
|
2312
|
|
|
2313
|
return luceneSearch;
|
|
2314
|
}
|
|
2315
|
|
|
2316
|
/**
|
|
2317
|
* @param queryString
|
|
2318
|
* @param classification
|
|
2319
|
* @param features
|
|
2320
|
* @param languages
|
|
2321
|
* @param descriptionElementQueryFactory
|
|
2322
|
* @return
|
|
2323
|
*/
|
|
2324
|
private BooleanQuery createByDescriptionElementFullTextQuery(String queryString,
|
|
2325
|
Classification classification, TaxonNode subtree, List<Feature> features,
|
|
2326
|
List<Language> languages, QueryFactory descriptionElementQueryFactory) {
|
|
2327
|
|
|
2328
|
Builder finalQueryBuilder = new Builder();
|
|
2329
|
Builder textQueryBuilder = new Builder();
|
|
2330
|
|
|
2331
|
if(!StringUtils.isEmpty(queryString)){
|
|
2332
|
|
|
2333
|
textQueryBuilder.add(descriptionElementQueryFactory.newTermQuery("titleCache", queryString), Occur.SHOULD);
|
|
2334
|
|
|
2335
|
// common name
|
|
2336
|
Builder nameQueryBuilder = new Builder();
|
|
2337
|
if(languages == null || languages.size() == 0){
|
|
2338
|
nameQueryBuilder.add(descriptionElementQueryFactory.newTermQuery("name", queryString), Occur.MUST);
|
|
2339
|
} else {
|
|
2340
|
Builder languageSubQueryBuilder = new Builder();
|
|
2341
|
for(Language lang : languages){
|
|
2342
|
languageSubQueryBuilder.add(descriptionElementQueryFactory.newTermQuery("language.uuid", lang.getUuid().toString(), false), Occur.SHOULD);
|
|
2343
|
}
|
|
2344
|
nameQueryBuilder.add(descriptionElementQueryFactory.newTermQuery("name", queryString), Occur.MUST);
|
|
2345
|
nameQueryBuilder.add(languageSubQueryBuilder.build(), Occur.MUST);
|
|
2346
|
}
|
|
2347
|
textQueryBuilder.add(nameQueryBuilder.build(), Occur.SHOULD);
|
|
2348
|
|
|
2349
|
|
|
2350
|
// text field from TextData
|
|
2351
|
textQueryBuilder.add(descriptionElementQueryFactory.newMultilanguageTextQuery("text", queryString, languages), Occur.SHOULD);
|
|
2352
|
|
|
2353
|
// --- TermBase fields - by representation ----
|
|
2354
|
// state field from CategoricalData
|
|
2355
|
textQueryBuilder.add(descriptionElementQueryFactory.newDefinedTermQuery("stateData.state", queryString, languages), Occur.SHOULD);
|
|
2356
|
|
|
2357
|
// state field from CategoricalData
|
|
2358
|
textQueryBuilder.add(descriptionElementQueryFactory.newDefinedTermQuery("stateData.modifyingText", queryString, languages), Occur.SHOULD);
|
|
2359
|
|
|
2360
|
// area field from Distribution
|
|
2361
|
textQueryBuilder.add(descriptionElementQueryFactory.newDefinedTermQuery("area", queryString, languages), Occur.SHOULD);
|
|
2362
|
|
|
2363
|
// status field from Distribution
|
|
2364
|
textQueryBuilder.add(descriptionElementQueryFactory.newDefinedTermQuery("status", queryString, languages), Occur.SHOULD);
|
|
2365
|
|
|
2366
|
finalQueryBuilder.add(textQueryBuilder.build(), Occur.MUST);
|
|
2367
|
|
|
2368
|
}
|
|
2369
|
// --- classification ----
|
|
2370
|
|
|
2371
|
|
|
2372
|
if(classification != null){
|
|
2373
|
finalQueryBuilder.add(descriptionElementQueryFactory.newEntityIdQuery("inDescription.taxon.taxonNodes.classification.id", classification), Occur.MUST);
|
|
2374
|
}
|
|
2375
|
if(subtree != null){
|
|
2376
|
finalQueryBuilder.add(descriptionElementQueryFactory.newTermQuery("inDescription.taxon.taxonNodes.treeIndex", subtree.treeIndexWc(), true), Occur.MUST);
|
|
2377
|
}
|
|
2378
|
|
|
2379
|
// --- IdentifieableEntity fields - by uuid
|
|
2380
|
if(features != null && features.size() > 0 ){
|
|
2381
|
finalQueryBuilder.add(descriptionElementQueryFactory.newEntityUuidsQuery("feature.uuid", features), Occur.MUST);
|
|
2382
|
}
|
|
2383
|
|
|
2384
|
// the description must be associated with a taxon
|
|
2385
|
finalQueryBuilder.add(descriptionElementQueryFactory.newIsNotNullQuery("inDescription.taxon.id"), Occur.MUST);
|
|
2386
|
|
|
2387
|
BooleanQuery finalQuery = finalQueryBuilder.build();
|
|
2388
|
logger.info("prepareByDescriptionElementFullTextSearch() query: " + finalQuery.toString());
|
|
2389
|
return finalQuery;
|
|
2390
|
}
|
|
2391
|
|
|
2392
|
@Override
|
|
2393
|
public List<Synonym> createInferredSynonyms(Taxon taxon, Classification classification, SynonymType type, boolean doWithMisappliedNames){
|
|
2394
|
|
|
2395
|
List <Synonym> inferredSynonyms = new ArrayList<>();
|
|
2396
|
List<Synonym> inferredSynonymsToBeRemoved = new ArrayList<>();
|
|
2397
|
|
|
2398
|
Map <UUID, IZoologicalName> zooHashMap = new HashMap<>();
|
|
2399
|
boolean includeUnpublished = INCLUDE_UNPUBLISHED;
|
|
2400
|
|
|
2401
|
UUID nameUuid= taxon.getName().getUuid();
|
|
2402
|
IZoologicalName taxonName = getZoologicalName(nameUuid, zooHashMap);
|
|
2403
|
String epithetOfTaxon = null;
|
|
2404
|
String infragenericEpithetOfTaxon = null;
|
|
2405
|
String infraspecificEpithetOfTaxon = null;
|
|
2406
|
if (taxonName.isSpecies()){
|
|
2407
|
epithetOfTaxon= taxonName.getSpecificEpithet();
|
|
2408
|
} else if (taxonName.isInfraGeneric()){
|
|
2409
|
infragenericEpithetOfTaxon = taxonName.getInfraGenericEpithet();
|
|
2410
|
} else if (taxonName.isInfraSpecific()){
|
|
2411
|
infraspecificEpithetOfTaxon = taxonName.getInfraSpecificEpithet();
|
|
2412
|
}
|
|
2413
|
String genusOfTaxon = taxonName.getGenusOrUninomial();
|
|
2414
|
Set<TaxonNode> nodes = taxon.getTaxonNodes();
|
|
2415
|
List<String> taxonNames = new ArrayList<>();
|
|
2416
|
|
|
2417
|
for (TaxonNode node: nodes){
|
|
2418
|
// Map<String, String> synonymsGenus = new HashMap<>(); // Changed this to be able to store the idInSource to a genusName
|
|
2419
|
// List<String> synonymsEpithet = new ArrayList<>();
|
|
2420
|
|
|
2421
|
if (node.getClassification().equals(classification)){
|
|
2422
|
if (!node.isTopmostNode()){
|
|
2423
|
TaxonNode parent = node.getParent();
|
|
2424
|
parent = CdmBase.deproxy(parent);
|
|
2425
|
TaxonName parentName = parent.getTaxon().getName();
|
|
2426
|
IZoologicalName zooParentName = CdmBase.deproxy(parentName);
|
|
2427
|
Taxon parentTaxon = CdmBase.deproxy(parent.getTaxon());
|
|
2428
|
|
|
2429
|
//create inferred synonyms for species, subspecies
|
|
2430
|
if ((parentName.isGenus() || parentName.isSpecies() || parentName.getRank().equals(Rank.SUBGENUS())) ){
|
|
2431
|
|
|
2432
|
Synonym inferredEpithet = null;
|
|
2433
|
Synonym inferredGenus = null;
|
|
2434
|
Synonym potentialCombination = null;
|
|
2435
|
|
|
2436
|
List<String> propertyPaths = new ArrayList<>();
|
|
2437
|
propertyPaths.add("synonym");
|
|
2438
|
propertyPaths.add("synonym.name");
|
|
2439
|
List<OrderHint> orderHintsSynonyms = new ArrayList<>();
|
|
2440
|
orderHintsSynonyms.add(new OrderHint("titleCache", SortOrder.ASCENDING));
|
|
2441
|
|
|
2442
|
List<Synonym> synonyMsOfParent = dao.getSynonyms(parentTaxon, SynonymType.HETEROTYPIC_SYNONYM_OF(), null, null,orderHintsSynonyms,propertyPaths);
|
|
2443
|
List<Synonym> synonymsOfTaxon= dao.getSynonyms(taxon, SynonymType.HETEROTYPIC_SYNONYM_OF(),
|
|
2444
|
null, null,orderHintsSynonyms,propertyPaths);
|
|
2445
|
|
|
2446
|
List<TaxonRelationship> taxonRelListParent = new ArrayList<>();
|
|
2447
|
List<TaxonRelationship> taxonRelListTaxon = new ArrayList<>();
|
|
2448
|
if (doWithMisappliedNames){
|
|
2449
|
List<OrderHint> orderHintsMisapplied = new ArrayList<>();
|
|
2450
|
orderHintsMisapplied.add(new OrderHint("relatedFrom.titleCache", SortOrder.ASCENDING));
|
|
2451
|
taxonRelListParent = dao.getTaxonRelationships(parentTaxon, TaxonRelationshipType.MISAPPLIED_NAME_FOR(),
|
|
2452
|
includeUnpublished, null, null, orderHintsMisapplied, propertyPaths, Direction.relatedTo);
|
|
2453
|
taxonRelListTaxon = dao.getTaxonRelationships(taxon, TaxonRelationshipType.MISAPPLIED_NAME_FOR(),
|
|
2454
|
includeUnpublished, null, null, orderHintsMisapplied, propertyPaths, Direction.relatedTo);
|
|
2455
|
}
|
|
2456
|
|
|
2457
|
if (type.equals(SynonymType.INFERRED_EPITHET_OF())){
|
|
2458
|
for (Synonym synonymRelationOfParent:synonyMsOfParent){
|
|
2459
|
|
|
2460
|
inferredEpithet = createInferredEpithets(taxon,
|
|
2461
|
zooHashMap, taxonName, epithetOfTaxon,
|
|
2462
|
infragenericEpithetOfTaxon,
|
|
2463
|
infraspecificEpithetOfTaxon,
|
|
2464
|
taxonNames, parentName,
|
|
2465
|
synonymRelationOfParent);
|
|
2466
|
|
|
2467
|
inferredSynonyms.add(inferredEpithet);
|
|
2468
|
zooHashMap.put(inferredEpithet.getName().getUuid(), inferredEpithet.getName());
|
|
2469
|
taxonNames.add(inferredEpithet.getName().getNameCache());
|
|
2470
|
}
|
|
2471
|
|
|
2472
|
if (doWithMisappliedNames){
|
|
2473
|
|
|
2474
|
for (TaxonRelationship taxonRelationship: taxonRelListParent){
|
|
2475
|
Taxon misappliedName = taxonRelationship.getFromTaxon();
|
|
2476
|
|
|
2477
|
inferredEpithet = createInferredEpithets(taxon,
|
|
2478
|
zooHashMap, taxonName, epithetOfTaxon,
|
|
2479
|
infragenericEpithetOfTaxon,
|
|
2480
|
infraspecificEpithetOfTaxon,
|
|
2481
|
taxonNames, parentName,
|
|
2482
|
misappliedName);
|
|
2483
|
|
|
2484
|
inferredSynonyms.add(inferredEpithet);
|
|
2485
|
zooHashMap.put(inferredEpithet.getName().getUuid(), inferredEpithet.getName());
|
|
2486
|
taxonNames.add(inferredEpithet.getName().getNameCache());
|
|
2487
|
}
|
|
2488
|
}
|
|
2489
|
|
|
2490
|
if (!taxonNames.isEmpty()){
|
|
2491
|
List<String> synNotInCDM = dao.taxaByNameNotInDB(taxonNames);
|
|
2492
|
if (!synNotInCDM.isEmpty()){
|
|
2493
|
inferredSynonymsToBeRemoved.clear();
|
|
2494
|
|
|
2495
|
for (Synonym syn :inferredSynonyms){
|
|
2496
|
IZoologicalName name = getZoologicalName(syn.getName().getUuid(), zooHashMap);
|
|
2497
|
if (!synNotInCDM.contains(name.getNameCache())){
|
|
2498
|
inferredSynonymsToBeRemoved.add(syn);
|
|
2499
|
}
|
|
2500
|
}
|
|
2501
|
|
|
2502
|
// Remove identified Synonyms from inferredSynonyms
|
|
2503
|
for (Synonym synonym : inferredSynonymsToBeRemoved) {
|
|
2504
|
inferredSynonyms.remove(synonym);
|
|
2505
|
}
|
|
2506
|
}
|
|
2507
|
}
|
|
2508
|
|
|
2509
|
}else if (type.equals(SynonymType.INFERRED_GENUS_OF())){
|
|
2510
|
|
|
2511
|
for (Synonym synonymRelationOfTaxon:synonymsOfTaxon){
|
|
2512
|
|
|
2513
|
inferredGenus = createInferredGenus(taxon,
|
|
2514
|
zooHashMap, taxonName, epithetOfTaxon,
|
|
2515
|
genusOfTaxon, taxonNames, zooParentName, synonymRelationOfTaxon);
|
|
2516
|
|
|
2517
|
inferredSynonyms.add(inferredGenus);
|
|
2518
|
zooHashMap.put(inferredGenus.getName().getUuid(), inferredGenus.getName());
|
|
2519
|
taxonNames.add(inferredGenus.getName().getNameCache());
|
|
2520
|
}
|
|
2521
|
|
|
2522
|
if (doWithMisappliedNames){
|
|
2523
|
|
|
2524
|
for (TaxonRelationship taxonRelationship: taxonRelListTaxon){
|
|
2525
|
Taxon misappliedName = taxonRelationship.getFromTaxon();
|
|
2526
|
inferredGenus = createInferredGenus(taxon, zooHashMap, taxonName, infraspecificEpithetOfTaxon, genusOfTaxon, taxonNames, zooParentName, misappliedName);
|
|
2527
|
|
|
2528
|
inferredSynonyms.add(inferredGenus);
|
|
2529
|
zooHashMap.put(inferredGenus.getName().getUuid(), inferredGenus.getName());
|
|
2530
|
taxonNames.add(inferredGenus.getName().getNameCache());
|
|
2531
|
}
|
|
2532
|
}
|
|
2533
|
|
|
2534
|
|
|
2535
|
if (!taxonNames.isEmpty()){
|
|
2536
|
List<String> synNotInCDM = dao.taxaByNameNotInDB(taxonNames);
|
|
2537
|
IZoologicalName name;
|
|
2538
|
if (!synNotInCDM.isEmpty()){
|
|
2539
|
inferredSynonymsToBeRemoved.clear();
|
|
2540
|
|
|
2541
|
for (Synonym syn :inferredSynonyms){
|
|
2542
|
name = getZoologicalName(syn.getName().getUuid(), zooHashMap);
|
|
2543
|
if (!synNotInCDM.contains(name.getNameCache())){
|
|
2544
|
inferredSynonymsToBeRemoved.add(syn);
|
|
2545
|
}
|
|
2546
|
}
|
|
2547
|
|
|
2548
|
// Remove identified Synonyms from inferredSynonyms
|
|
2549
|
for (Synonym synonym : inferredSynonymsToBeRemoved) {
|
|
2550
|
inferredSynonyms.remove(synonym);
|
|
2551
|
}
|
|
2552
|
}
|
|
2553
|
}
|
|
2554
|
|
|
2555
|
}else if (type.equals(SynonymType.POTENTIAL_COMBINATION_OF())){
|
|
2556
|
|
|
2557
|
Reference sourceReference = null; // TODO: Determination of sourceReference is redundant
|
|
2558
|
//for all synonyms of the parent...
|
|
2559
|
for (Synonym synonymRelationOfParent:synonyMsOfParent){
|
|
2560
|
TaxonName synName;
|
|
2561
|
HibernateProxyHelper.deproxy(synonymRelationOfParent);
|
|
2562
|
|
|
2563
|
synName = synonymRelationOfParent.getName();
|
|
2564
|
|
|
2565
|
// Set the sourceReference
|
|
2566
|
sourceReference = synonymRelationOfParent.getSec();
|
|
2567
|
|
|
2568
|
// Determine the idInSource
|
|
2569
|
String idInSourceParent = getIdInSource(synonymRelationOfParent);
|
|
2570
|
|
|
2571
|
IZoologicalName parentSynZooName = getZoologicalName(synName.getUuid(), zooHashMap);
|
|
2572
|
String synParentGenus = parentSynZooName.getGenusOrUninomial();
|
|
2573
|
String synParentInfragenericName = null;
|
|
2574
|
String synParentSpecificEpithet = null;
|
|
2575
|
|
|
2576
|
if (parentSynZooName.isInfraGeneric()){
|
|
2577
|
synParentInfragenericName = parentSynZooName.getInfraGenericEpithet();
|
|
2578
|
}
|
|
2579
|
if (parentSynZooName.isSpecies()){
|
|
2580
|
synParentSpecificEpithet = parentSynZooName.getSpecificEpithet();
|
|
2581
|
}
|
|
2582
|
|
|
2583
|
/* if (synGenusName != null && !synonymsGenus.containsKey(synGenusName)){
|
|
2584
|
synonymsGenus.put(synGenusName, idInSource);
|
|
2585
|
}*/
|
|
2586
|
|
|
2587
|
//for all synonyms of the taxon
|
|
2588
|
|
|
2589
|
for (Synonym synonymRelationOfTaxon:synonymsOfTaxon){
|
|
2590
|
|
|
2591
|
IZoologicalName zooSynName = getZoologicalName(synonymRelationOfTaxon.getName().getUuid(), zooHashMap);
|
|
2592
|
potentialCombination = createPotentialCombination(idInSourceParent, parentSynZooName, zooSynName,
|
|
2593
|
synParentGenus,
|
|
2594
|
synParentInfragenericName,
|
|
2595
|
synParentSpecificEpithet, synonymRelationOfTaxon, zooHashMap);
|
|
2596
|
|
|
2597
|
taxon.addSynonym(potentialCombination, SynonymType.POTENTIAL_COMBINATION_OF());
|
|
2598
|
inferredSynonyms.add(potentialCombination);
|
|
2599
|
zooHashMap.put(potentialCombination.getName().getUuid(), potentialCombination.getName());
|
|
2600
|
taxonNames.add(potentialCombination.getName().getNameCache());
|
|
2601
|
}
|
|
2602
|
}
|
|
2603
|
|
|
2604
|
if (doWithMisappliedNames){
|
|
2605
|
|
|
2606
|
for (TaxonRelationship parentRelationship: taxonRelListParent){
|
|
2607
|
|
|
2608
|
TaxonName misappliedParentName;
|
|
2609
|
|
|
2610
|
Taxon misappliedParent = parentRelationship.getFromTaxon();
|
|
2611
|
misappliedParentName = misappliedParent.getName();
|
|
2612
|
|
|
2613
|
HibernateProxyHelper.deproxy(misappliedParent);
|
|
2614
|
|
|
2615
|
// Set the sourceReference
|
|
2616
|
sourceReference = misappliedParent.getSec();
|
|
2617
|
|
|
2618
|
// Determine the idInSource
|
|
2619
|
String idInSourceParent = getIdInSource(misappliedParent);
|
|
2620
|
|
|
2621
|
IZoologicalName parentSynZooName = getZoologicalName(misappliedParentName.getUuid(), zooHashMap);
|
|
2622
|
String synParentGenus = parentSynZooName.getGenusOrUninomial();
|
|
2623
|
String synParentInfragenericName = null;
|
|
2624
|
String synParentSpecificEpithet = null;
|
|
2625
|
|
|
2626
|
if (parentSynZooName.isInfraGeneric()){
|
|
2627
|
synParentInfragenericName = parentSynZooName.getInfraGenericEpithet();
|
|
2628
|
}
|
|
2629
|
if (parentSynZooName.isSpecies()){
|
|
2630
|
synParentSpecificEpithet = parentSynZooName.getSpecificEpithet();
|
|
2631
|
}
|
|
2632
|
|
|
2633
|
for (TaxonRelationship taxonRelationship: taxonRelListTaxon){
|
|
2634
|
Taxon misappliedName = taxonRelationship.getFromTaxon();
|
|
2635
|
IZoologicalName zooMisappliedName = getZoologicalName(misappliedName.getName().getUuid(), zooHashMap);
|
|
2636
|
potentialCombination = createPotentialCombination(
|
|
2637
|
idInSourceParent, parentSynZooName, zooMisappliedName,
|
|
2638
|
synParentGenus,
|
|
2639
|
synParentInfragenericName,
|
|
2640
|
synParentSpecificEpithet, misappliedName, zooHashMap);
|
|
2641
|
|
|
2642
|
taxon.addSynonym(potentialCombination, SynonymType.POTENTIAL_COMBINATION_OF());
|
|
2643
|
inferredSynonyms.add(potentialCombination);
|
|
2644
|
zooHashMap.put(potentialCombination.getName().getUuid(), potentialCombination.getName());
|
|
2645
|
taxonNames.add(potentialCombination.getName().getNameCache());
|
|
2646
|
}
|
|
2647
|
}
|
|
2648
|
}
|
|
2649
|
|
|
2650
|
if (!taxonNames.isEmpty()){
|
|
2651
|
List<String> synNotInCDM = dao.taxaByNameNotInDB(taxonNames);
|
|
2652
|
IZoologicalName name;
|
|
2653
|
if (!synNotInCDM.isEmpty()){
|
|
2654
|
inferredSynonymsToBeRemoved.clear();
|
|
2655
|
for (Synonym syn :inferredSynonyms){
|
|
2656
|
try{
|
|
2657
|
name = syn.getName();
|
|
2658
|
}catch (ClassCastException e){
|
|
2659
|
name = getZoologicalName(syn.getName().getUuid(), zooHashMap);
|
|
2660
|
}
|
|
2661
|
if (!synNotInCDM.contains(name.getNameCache())){
|
|
2662
|
inferredSynonymsToBeRemoved.add(syn);
|
|
2663
|
}
|
|
2664
|
}
|
|
2665
|
// Remove identified Synonyms from inferredSynonyms
|
|
2666
|
for (Synonym synonym : inferredSynonymsToBeRemoved) {
|
|
2667
|
inferredSynonyms.remove(synonym);
|
|
2668
|
}
|
|
2669
|
}
|
|
2670
|
}
|
|
2671
|
}
|
|
2672
|
}else {
|
|
2673
|
logger.info("The synonym type is not defined.");
|
|
2674
|
return inferredSynonyms;
|
|
2675
|
}
|
|
2676
|
}
|
|
2677
|
}
|
|
2678
|
}
|
|
2679
|
|
|
2680
|
return inferredSynonyms;
|
|
2681
|
}
|
|
2682
|
|
|
2683
|
private Synonym createPotentialCombination(String idInSourceParent,
|
|
2684
|
IZoologicalName parentSynZooName, IZoologicalName zooSynName, String synParentGenus,
|
|
2685
|
String synParentInfragenericName, String synParentSpecificEpithet,
|
|
2686
|
TaxonBase<?> syn, Map<UUID, IZoologicalName> zooHashMap) {
|
|
2687
|
Synonym potentialCombination;
|
|
2688
|
Reference sourceReference;
|
|
2689
|
IZoologicalName inferredSynName;
|
|
2690
|
HibernateProxyHelper.deproxy(syn);
|
|
2691
|
|
|
2692
|
// Set sourceReference
|
|
2693
|
sourceReference = syn.getSec();
|
|
2694
|
if (sourceReference == null){
|
|
2695
|
logger.warn("The synonym has no sec reference because it is a misapplied name! Take the sec reference of taxon");
|
|
2696
|
//TODO:Remove
|
|
2697
|
if (!parentSynZooName.getTaxa().isEmpty()){
|
|
2698
|
TaxonBase<?> taxon = parentSynZooName.getTaxa().iterator().next();
|
|
2699
|
|
|
2700
|
sourceReference = taxon.getSec();
|
|
2701
|
}
|
|
2702
|
}
|
|
2703
|
String synTaxonSpecificEpithet = zooSynName.getSpecificEpithet();
|
|
2704
|
|
|
2705
|
String synTaxonInfraSpecificName= null;
|
|
2706
|
|
|
2707
|
if (parentSynZooName.isSpecies()){
|
|
2708
|
synTaxonInfraSpecificName = zooSynName.getInfraSpecificEpithet();
|
|
2709
|
}
|
|
2710
|
|
|
2711
|
/*if (epithetName != null && !synonymsEpithet.contains(epithetName)){
|
|
2712
|
synonymsEpithet.add(epithetName);
|
|
2713
|
}*/
|
|
2714
|
|
|
2715
|
//create potential combinations...
|
|
2716
|
inferredSynName = TaxonNameFactory.NewZoologicalInstance(syn.getName().getRank());
|
|
2717
|
|
|
2718
|
inferredSynName.setGenusOrUninomial(synParentGenus);
|
|
2719
|
if (zooSynName.isSpecies()){
|
|
2720
|
inferredSynName.setSpecificEpithet(synTaxonSpecificEpithet);
|
|
2721
|
if (parentSynZooName.isInfraGeneric()){
|
|
2722
|
inferredSynName.setInfraGenericEpithet(synParentInfragenericName);
|
|
2723
|
}
|
|
2724
|
}
|
|
2725
|
if (zooSynName.isInfraSpecific()){
|
|
2726
|
inferredSynName.setSpecificEpithet(synParentSpecificEpithet);
|
|
2727
|
inferredSynName.setInfraSpecificEpithet(synTaxonInfraSpecificName);
|
|
2728
|
}
|
|
2729
|
if (parentSynZooName.isInfraGeneric()){
|
|
2730
|
inferredSynName.setInfraGenericEpithet(synParentInfragenericName);
|
|
2731
|
}
|
|
2732
|
|
|
2733
|
potentialCombination = Synonym.NewInstance(inferredSynName, null);
|
|
2734
|
|
|
2735
|
// Set the sourceReference
|
|
2736
|
potentialCombination.setSec(sourceReference);
|
|
2737
|
|
|
2738
|
|
|
2739
|
// Determine the idInSource
|
|
2740
|
String idInSourceSyn= getIdInSource(syn);
|
|
2741
|
|
|
2742
|
if (idInSourceParent != null && idInSourceSyn != null) {
|
|
2743
|
IdentifiableSource originalSource = IdentifiableSource.NewInstance(OriginalSourceType.Transformation, idInSourceSyn + "; " + idInSourceParent, POTENTIAL_COMBINATION_NAMESPACE, sourceReference, null);
|
|
2744
|
inferredSynName.addSource(originalSource);
|
|
2745
|
originalSource = IdentifiableSource.NewInstance(OriginalSourceType.Transformation, idInSourceSyn + "; " + idInSourceParent, POTENTIAL_COMBINATION_NAMESPACE, sourceReference, null);
|
|
2746
|
potentialCombination.addSource(originalSource);
|
|
2747
|
}
|
|
2748
|
|
|
2749
|
return potentialCombination;
|
|
2750
|
}
|
|
2751
|
|
|
2752
|
private Synonym createInferredGenus(Taxon taxon,
|
|
2753
|
Map<UUID, IZoologicalName> zooHashMap, IZoologicalName taxonName,
|
|
2754
|
String epithetOfTaxon, String genusOfTaxon,
|
|
2755
|
List<String> taxonNames, IZoologicalName zooParentName,
|
|
2756
|
TaxonBase syn) {
|
|
2757
|
|
|
2758
|
Synonym inferredGenus;
|
|
2759
|
TaxonName synName;
|
|
2760
|
IZoologicalName inferredSynName;
|
|
2761
|
synName =syn.getName();
|
|
2762
|
HibernateProxyHelper.deproxy(syn);
|
|
2763
|
|
|
2764
|
// Determine the idInSource
|
|
2765
|
String idInSourceSyn = getIdInSource(syn);
|
|
2766
|
String idInSourceTaxon = getIdInSource(taxon);
|
|
2767
|
// Determine the sourceReference
|
|
2768
|
Reference sourceReference = syn.getSec();
|
|
2769
|
|
|
2770
|
//logger.warn(sourceReference.getTitleCache());
|
|
2771
|
|
|
2772
|
synName = syn.getName();
|
|
2773
|
IZoologicalName synZooName = getZoologicalName(synName.getUuid(), zooHashMap);
|
|
2774
|
String synSpeciesEpithetName = synZooName.getSpecificEpithet();
|
|
2775
|
/* if (synonymsEpithet != null && !synonymsEpithet.contains(synSpeciesEpithetName)){
|
|
2776
|
synonymsEpithet.add(synSpeciesEpithetName);
|
|
2777
|
}*/
|
|
2778
|
|
|
2779
|
inferredSynName = TaxonNameFactory.NewZoologicalInstance(taxon.getName().getRank());
|
|
2780
|
//TODO:differ between parent is genus and taxon is species, parent is subgenus and taxon is species, parent is species and taxon is subspecies and parent is genus and taxon is subgenus...
|
|
2781
|
|
|
2782
|
inferredSynName.setGenusOrUninomial(genusOfTaxon);
|
|
2783
|
if (zooParentName.isInfraGeneric()){
|
|
2784
|
inferredSynName.setInfraGenericEpithet(zooParentName.getInfraGenericEpithet());
|
|
2785
|
}
|
|
2786
|
|
|
2787
|
if (taxonName.isSpecies()){
|
|
2788
|
inferredSynName.setSpecificEpithet(synSpeciesEpithetName);
|
|
2789
|
}
|
|
2790
|
if (taxonName.isInfraSpecific()){
|
|
2791
|
inferredSynName.setSpecificEpithet(epithetOfTaxon);
|
|
2792
|
inferredSynName.setInfraSpecificEpithet(synZooName.getInfraGenericEpithet());
|
|
2793
|
}
|
|
2794
|
|
|
2795
|
inferredGenus = Synonym.NewInstance(inferredSynName, null);
|
|
2796
|
|
|
2797
|
// Set the sourceReference
|
|
2798
|
inferredGenus.setSec(sourceReference);
|
|
2799
|
|
|
2800
|
// Add the original source
|
|
2801
|
if (idInSourceSyn != null && idInSourceTaxon != null) {
|
|
2802
|
IdentifiableSource originalSource = IdentifiableSource.NewInstance(OriginalSourceType.Transformation,
|
|
2803
|
idInSourceSyn + "; " + idInSourceTaxon, INFERRED_GENUS_NAMESPACE, sourceReference, null);
|
|
2804
|
inferredGenus.addSource(originalSource);
|
|
2805
|
|
|
2806
|
originalSource = IdentifiableSource.NewInstance(OriginalSourceType.Transformation,
|
|
2807
|
idInSourceSyn + "; " + idInSourceTaxon, INFERRED_GENUS_NAMESPACE, sourceReference, null);
|
|
2808
|
inferredSynName.addSource(originalSource);
|
|
2809
|
originalSource = null;
|
|
2810
|
|
|
2811
|
}else{
|
|
2812
|
logger.error("There is an idInSource missing: " + idInSourceSyn + " of Synonym or " + idInSourceTaxon + " of Taxon");
|
|
2813
|
IdentifiableSource originalSource = IdentifiableSource.NewInstance(OriginalSourceType.Transformation,
|
|
2814
|
idInSourceSyn + "; " + idInSourceTaxon, INFERRED_GENUS_NAMESPACE, sourceReference, null);
|
|
2815
|
inferredGenus.addSource(originalSource);
|
|
2816
|
|
|
2817
|
originalSource = IdentifiableSource.NewInstance(OriginalSourceType.Transformation,
|
|
2818
|
idInSourceSyn + "; " + idInSourceTaxon, INFERRED_GENUS_NAMESPACE, sourceReference, null);
|
|
2819
|
inferredSynName.addSource(originalSource);
|
|
2820
|
originalSource = null;
|
|
2821
|
}
|
|
2822
|
|
|
2823
|
taxon.addSynonym(inferredGenus, SynonymType.INFERRED_GENUS_OF());
|
|
2824
|
|
|
2825
|
return inferredGenus;
|
|
2826
|
}
|
|
2827
|
|
|
2828
|
private Synonym createInferredEpithets(Taxon taxon,
|
|
2829
|
Map<UUID, IZoologicalName> zooHashMap, IZoologicalName taxonName,
|
|
2830
|
String epithetOfTaxon, String infragenericEpithetOfTaxon,
|
|
2831
|
String infraspecificEpithetOfTaxon, List<String> taxonNames,
|
|
2832
|
TaxonName parentName, TaxonBase<?> syn) {
|
|
2833
|
|
|
2834
|
Synonym inferredEpithet;
|
|
2835
|
TaxonName synName;
|
|
2836
|
IZoologicalName inferredSynName;
|
|
2837
|
HibernateProxyHelper.deproxy(syn);
|
|
2838
|
|
|
2839
|
// Determine the idInSource
|
|
2840
|
String idInSourceSyn = getIdInSource(syn);
|
|
2841
|
String idInSourceTaxon = getIdInSource(taxon);
|
|
2842
|
// Determine the sourceReference
|
|
2843
|
Reference sourceReference = syn.getSec();
|
|
2844
|
|
|
2845
|
if (sourceReference == null){
|
|
2846
|
logger.warn("The synonym has no sec reference because it is a misapplied name! Take the sec reference of taxon" + taxon.getSec());
|
|
2847
|
sourceReference = taxon.getSec();
|
|
2848
|
}
|
|
2849
|
|
|
2850
|
synName = syn.getName();
|
|
2851
|
IZoologicalName zooSynName = getZoologicalName(synName.getUuid(), zooHashMap);
|
|
2852
|
String synGenusName = zooSynName.getGenusOrUninomial();
|
|
2853
|
String synInfraGenericEpithet = null;
|
|
2854
|
String synSpecificEpithet = null;
|
|
2855
|
|
|
2856
|
if (zooSynName.getInfraGenericEpithet() != null){
|
|
2857
|
synInfraGenericEpithet = zooSynName.getInfraGenericEpithet();
|
|
2858
|
}
|
|
2859
|
|
|
2860
|
if (zooSynName.isInfraSpecific()){
|
|
2861
|
synSpecificEpithet = zooSynName.getSpecificEpithet();
|
|
2862
|
}
|
|
2863
|
|
|
2864
|
/* if (synGenusName != null && !synonymsGenus.containsKey(synGenusName)){
|
|
2865
|
synonymsGenus.put(synGenusName, idInSource);
|
|
2866
|
}*/
|
|
2867
|
|
|
2868
|
inferredSynName = TaxonNameFactory.NewZoologicalInstance(taxon.getName().getRank());
|
|
2869
|
|
|
2870
|
// DEBUG TODO: for subgenus or subspecies the infrageneric or infraspecific epithet should be used!!!
|
|
2871
|
if (epithetOfTaxon == null && infragenericEpithetOfTaxon == null && infraspecificEpithetOfTaxon == null) {
|
|
2872
|
logger.error("This specificEpithet is NULL" + taxon.getTitleCache());
|
|
2873
|
}
|
|
2874
|
inferredSynName.setGenusOrUninomial(synGenusName);
|
|
2875
|
|
|
2876
|
if (parentName.isInfraGeneric()){
|
|
2877
|
inferredSynName.setInfraGenericEpithet(synInfraGenericEpithet);
|
|
2878
|
}
|
|
2879
|
if (taxonName.isSpecies()){
|
|
2880
|
inferredSynName.setSpecificEpithet(epithetOfTaxon);
|
|
2881
|
}else if (taxonName.isInfraSpecific()){
|
|
2882
|
inferredSynName.setSpecificEpithet(synSpecificEpithet);
|
|
2883
|
inferredSynName.setInfraSpecificEpithet(infraspecificEpithetOfTaxon);
|
|
2884
|
}
|
|
2885
|
|
|
2886
|
inferredEpithet = Synonym.NewInstance(inferredSynName, null);
|
|
2887
|
|
|
2888
|
// Set the sourceReference
|
|
2889
|
inferredEpithet.setSec(sourceReference);
|
|
2890
|
|
|
2891
|
/* Add the original source
|
|
2892
|
if (idInSource != null) {
|
|
2893
|
IdentifiableSource originalSource = IdentifiableSource.NewInstance(idInSource, "InferredEpithetOf", syn.getSec(), null);
|
|
2894
|
|
|
2895
|
// Add the citation
|
|
2896
|
Reference citation = getCitation(syn);
|
|
2897
|
if (citation != null) {
|
|
2898
|
originalSource.setCitation(citation);
|
|
2899
|
inferredEpithet.addSource(originalSource);
|
|
2900
|
}
|
|
2901
|
}*/
|
|
2902
|
String taxonId = idInSourceTaxon+ "; " + idInSourceSyn;
|
|
2903
|
|
|
2904
|
|
|
2905
|
IdentifiableSource originalSource = IdentifiableSource.NewInstance(OriginalSourceType.Transformation,
|
|
2906
|
taxonId, INFERRED_EPITHET_NAMESPACE, sourceReference, null);
|
|
2907
|
|
|
2908
|
inferredEpithet.addSource(originalSource);
|
|
2909
|
|
|
2910
|
originalSource = IdentifiableSource.NewInstance(OriginalSourceType.Transformation,
|
|
2911
|
taxonId, INFERRED_EPITHET_NAMESPACE, sourceReference, null);
|
|
2912
|
|
|
2913
|
inferredSynName.addSource(originalSource);
|
|
2914
|
|
|
2915
|
taxon.addSynonym(inferredEpithet, SynonymType.INFERRED_EPITHET_OF());
|
|
2916
|
|
|
2917
|
return inferredEpithet;
|
|
2918
|
}
|
|
2919
|
|
|
2920
|
/**
|
|
2921
|
* Returns an existing IZoologicalName or extends an internal hashmap if it does not exist.
|
|
2922
|
* Very likely only useful for createInferredSynonyms().
|
|
2923
|
* @param uuid
|
|
2924
|
* @param zooHashMap
|
|
2925
|
* @return
|
|
2926
|
*/
|
|
2927
|
private IZoologicalName getZoologicalName(UUID uuid, Map <UUID, IZoologicalName> zooHashMap) {
|
|
2928
|
IZoologicalName taxonName =nameDao.findZoologicalNameByUUID(uuid);
|
|
2929
|
if (taxonName == null) {
|
|
2930
|
taxonName = zooHashMap.get(uuid);
|
|
2931
|
}
|
|
2932
|
return taxonName;
|
|
2933
|
}
|
|
2934
|
|
|
2935
|
/**
|
|
2936
|
* Returns the idInSource for a given Synonym.
|
|
2937
|
* @param syn
|
|
2938
|
*/
|
|
2939
|
private String getIdInSource(TaxonBase<?> taxonBase) {
|
|
2940
|
String idInSource = null;
|
|
2941
|
Set<IdentifiableSource> sources = taxonBase.getSources();
|
|
2942
|
if (sources.size() == 1) {
|
|
2943
|
IdentifiableSource source = sources.iterator().next();
|
|
2944
|
if (source != null) {
|
|
2945
|
idInSource = source.getIdInSource();
|
|
2946
|
}
|
|
2947
|
} else if (sources.size() > 1) {
|
|
2948
|
int count = 1;
|
|
2949
|
idInSource = "";
|
|
2950
|
for (IdentifiableSource source : sources) {
|
|
2951
|
idInSource += source.getIdInSource();
|
|
2952
|
if (count < sources.size()) {
|
|
2953
|
idInSource += "; ";
|
|
2954
|
}
|
|
2955
|
count++;
|
|
2956
|
}
|
|
2957
|
} else if (sources.size() == 0){
|
|
2958
|
logger.warn("No idInSource for TaxonBase " + taxonBase.getUuid() + " - " + taxonBase.getTitleCache());
|
|
2959
|
}
|
|
2960
|
|
|
2961
|
return idInSource;
|
|
2962
|
}
|
|
2963
|
|
|
2964
|
/**
|
|
2965
|
* Returns the citation for a given Synonym.
|
|
2966
|
* @param syn
|
|
2967
|
*/
|
|
2968
|
private Reference getCitation(Synonym syn) {
|
|
2969
|
Reference citation = null;
|
|
2970
|
Set<IdentifiableSource> sources = syn.getSources();
|
|
2971
|
if (sources.size() == 1) {
|
|
2972
|
IdentifiableSource source = sources.iterator().next();
|
|
2973
|
if (source != null) {
|
|
2974
|
citation = source.getCitation();
|
|
2975
|
}
|
|
2976
|
} else if (sources.size() > 1) {
|
|
2977
|
logger.warn("This Synonym has more than one source: " + syn.getUuid() + " (" + syn.getTitleCache() +")");
|
|
2978
|
}
|
|
2979
|
|
|
2980
|
return citation;
|
|
2981
|
}
|
|
2982
|
|
|
2983
|
@Override
|
|
2984
|
public List<Synonym> createAllInferredSynonyms(Taxon taxon, Classification tree, boolean doWithMisappliedNames){
|
|
2985
|
List <Synonym> inferredSynonyms = new ArrayList<>();
|
|
2986
|
|
|
2987
|
inferredSynonyms.addAll(createInferredSynonyms(taxon, tree, SynonymType.INFERRED_EPITHET_OF(), doWithMisappliedNames));
|
|
2988
|
inferredSynonyms.addAll(createInferredSynonyms(taxon, tree, SynonymType.INFERRED_GENUS_OF(), doWithMisappliedNames));
|
|
2989
|
inferredSynonyms.addAll(createInferredSynonyms(taxon, tree, SynonymType.POTENTIAL_COMBINATION_OF(), doWithMisappliedNames));
|
|
2990
|
|
|
2991
|
return inferredSynonyms;
|
|
2992
|
}
|
|
2993
|
|
|
2994
|
@Override
|
|
2995
|
public List<Classification> listClassifications(TaxonBase taxonBase, Integer limit, Integer start, List<String> propertyPaths) {
|
|
2996
|
|
|
2997
|
// TODO quickly implemented, create according dao !!!!
|
|
2998
|
Set<TaxonNode> nodes = new HashSet<>();
|
|
2999
|
Set<Classification> classifications = new HashSet<>();
|
|
3000
|
List<Classification> list = new ArrayList<>();
|
|
3001
|
|
|
3002
|
if (taxonBase == null) {
|
|
3003
|
return list;
|
|
3004
|
}
|
|
3005
|
|
|
3006
|
taxonBase = load(taxonBase.getUuid());
|
|
3007
|
|
|
3008
|
if (taxonBase instanceof Taxon) {
|
|
3009
|
nodes.addAll(((Taxon)taxonBase).getTaxonNodes());
|
|
3010
|
} else {
|
|
3011
|
Taxon taxon = ((Synonym)taxonBase).getAcceptedTaxon();
|
|
3012
|
if (taxon != null){
|
|
3013
|
nodes.addAll(taxon.getTaxonNodes());
|
|
3014
|
}
|
|
3015
|
}
|
|
3016
|
for (TaxonNode node : nodes) {
|
|
3017
|
classifications.add(node.getClassification());
|
|
3018
|
}
|
|
3019
|
list.addAll(classifications);
|
|
3020
|
return list;
|
|
3021
|
}
|
|
3022
|
|
|
3023
|
@Override
|
|
3024
|
@Transactional(readOnly = false)
|
|
3025
|
public UpdateResult changeRelatedTaxonToSynonym(UUID fromTaxonUuid,
|
|
3026
|
UUID toTaxonUuid,
|
|
3027
|
TaxonRelationshipType oldRelationshipType,
|
|
3028
|
SynonymType synonymType) throws DataChangeNoRollbackException {
|
|
3029
|
UpdateResult result = new UpdateResult();
|
|
3030
|
Taxon fromTaxon = (Taxon) dao.load(fromTaxonUuid);
|
|
3031
|
Taxon toTaxon = (Taxon) dao.load(toTaxonUuid);
|
|
3032
|
result = changeRelatedTaxonToSynonym(fromTaxon, toTaxon, oldRelationshipType, synonymType);
|
|
3033
|
|
|
3034
|
result.addUpdatedObject(toTaxon);
|
|
3035
|
result.addUpdatedObject(result.getCdmEntity());
|
|
3036
|
|
|
3037
|
return result;
|
|
3038
|
}
|
|
3039
|
|
|
3040
|
@Override
|
|
3041
|
@Transactional(readOnly = false)
|
|
3042
|
public UpdateResult changeRelatedTaxonToSynonym(Taxon fromTaxon, Taxon toTaxon, TaxonRelationshipType oldRelationshipType,
|
|
3043
|
SynonymType synonymType) throws DataChangeNoRollbackException {
|
|
3044
|
|
|
3045
|
UpdateResult result = new UpdateResult();
|
|
3046
|
// Create new synonym using concept name
|
|
3047
|
TaxonName synonymName = fromTaxon.getName();
|
|
3048
|
|
|
3049
|
// Remove concept relation from taxon
|
|
3050
|
toTaxon.removeTaxon(fromTaxon, oldRelationshipType);
|
|
3051
|
|
|
3052
|
// Create a new synonym for the taxon
|
|
3053
|
Synonym synonym;
|
|
3054
|
if (synonymType != null
|
|
3055
|
&& synonymType.equals(SynonymType.HOMOTYPIC_SYNONYM_OF())){
|
|
3056
|
synonym = Synonym.NewInstance(synonymName, fromTaxon.getSec());
|
|
3057
|
toTaxon.addHomotypicSynonym(synonym);
|
|
3058
|
} else{
|
|
3059
|
synonym = toTaxon.addHeterotypicSynonymName(synonymName);
|
|
3060
|
}
|
|
3061
|
//keep the publish flag
|
|
3062
|
synonym.setPublish(fromTaxon.isPublish());
|
|
3063
|
this.saveOrUpdate(toTaxon);
|
|
3064
|
//TODO: configurator and classification
|
|
3065
|
TaxonDeletionConfigurator config = new TaxonDeletionConfigurator();
|
|
3066
|
config.setDeleteNameIfPossible(false);
|
|
3067
|
result.includeResult(this.deleteTaxon(fromTaxon.getUuid(), config, null));
|
|
3068
|
result.setCdmEntity(synonym);
|
|
3069
|
result.addUpdatedObject(toTaxon);
|
|
3070
|
result.addUpdatedObject(synonym);
|
|
3071
|
return result;
|
|
3072
|
}
|
|
3073
|
|
|
3074
|
@Override
|
|
3075
|
public DeleteResult isDeletable(UUID taxonBaseUuid, DeleteConfiguratorBase config){
|
|
3076
|
DeleteResult result = new DeleteResult();
|
|
3077
|
TaxonBase<?> taxonBase = load(taxonBaseUuid);
|
|
3078
|
Set<CdmBase> references = commonService.getReferencingObjectsForDeletion(taxonBase);
|
|
3079
|
if (taxonBase instanceof Taxon){
|
|
3080
|
TaxonDeletionConfigurator taxonConfig = (TaxonDeletionConfigurator) config;
|
|
3081
|
List<String> propertyPaths = new ArrayList<>();
|
|
3082
|
propertyPaths.add("taxonNodes");
|
|
3083
|
Taxon taxon = (Taxon)load(taxonBaseUuid, propertyPaths);
|
|
3084
|
|
|
3085
|
result = isDeletableForTaxon(references, taxonConfig );
|
|
3086
|
|
|
3087
|
if (taxonConfig.isDeleteNameIfPossible()){
|
|
3088
|
if (taxonBase.getName() != null){
|
|
3089
|
DeleteResult nameResult = nameService.isDeletable(taxonBase.getName().getUuid(), taxonConfig.getNameDeletionConfig(), taxon.getUuid());
|
|
3090
|
if (!nameResult.isOk()){
|
|
3091
|
result.addExceptions(nameResult.getExceptions());
|
|
3092
|
}
|
|
3093
|
}
|
|
3094
|
|
|
3095
|
}
|
|
3096
|
}else{
|
|
3097
|
SynonymDeletionConfigurator synonymConfig = (SynonymDeletionConfigurator) config;
|
|
3098
|
result = isDeletableForSynonym(references, synonymConfig);
|
|
3099
|
if (synonymConfig.isDeleteNameIfPossible() && taxonBase.getName() != null){
|
|
3100
|
DeleteResult nameResult = nameService.isDeletable(taxonBase.getName().getUuid(), synonymConfig.getNameDeletionConfig(), taxonBase.getUuid());
|
|
3101
|
if (!nameResult.isOk()){
|
|
3102
|
result.addExceptions(nameResult.getExceptions());
|
|
3103
|
|
|
3104
|
}
|
|
3105
|
}
|
|
3106
|
}
|
|
3107
|
|
|
3108
|
return result;
|
|
3109
|
}
|
|
3110
|
|
|
3111
|
private DeleteResult isDeletableForSynonym(Set<CdmBase> references, SynonymDeletionConfigurator config){
|
|
3112
|
|
|
3113
|
DeleteResult result = new DeleteResult();
|
|
3114
|
for (CdmBase ref: references){
|
|
3115
|
if (!(ref instanceof Taxon || ref instanceof TaxonName || ref instanceof SecundumSource)){
|
|
3116
|
String message = "The Synonym can't be deleted as long as it is referenced by " + ref.getClass().getSimpleName() + " with id "+ ref.getId();
|
|
3117
|
result.addException(new ReferencedObjectUndeletableException(message));
|
|
3118
|
result.addRelatedObject(ref);
|
|
3119
|
result.setAbort();
|
|
3120
|
}
|
|
3121
|
}
|
|
3122
|
|
|
3123
|
return result;
|
|
3124
|
}
|
|
3125
|
|
|
3126
|
private DeleteResult isDeletableForTaxon(Set<CdmBase> references, TaxonDeletionConfigurator config){
|
|
3127
|
String message = null;
|
|
3128
|
DeleteResult result = new DeleteResult();
|
|
3129
|
for (CdmBase ref: references){
|
|
3130
|
if (!(ref instanceof TaxonName || ref instanceof SecundumSource)){
|
|
3131
|
message = null;
|
|
3132
|
if (!config.isDeleteSynonymRelations() && (ref instanceof Synonym)){
|
|
3133
|
message = "The taxon can't be deleted as long as it has synonyms.";
|
|
3134
|
}
|
|
3135
|
if (!config.isDeleteDescriptions() && (ref instanceof DescriptionBase)){
|
|
3136
|
message = "The taxon can't be deleted as long as it has factual data.";
|
|
3137
|
}
|
|
3138
|
|
|
3139
|
if (!config.isDeleteTaxonNodes() && (ref instanceof TaxonNode)){
|
|
3140
|
message = "The taxon can't be deleted as long as it belongs to a taxon node.";
|
|
3141
|
}
|
|
3142
|
if (ref instanceof TaxonNode && config.getClassificationUuid() != null && !config.isDeleteInAllClassifications() && !((TaxonNode)ref).getClassification().getUuid().equals(config.getClassificationUuid())){
|
|
3143
|
message = "The taxon can't be deleted as long as it is used in more than one classification";
|
|
3144
|
|
|
3145
|
}
|
|
3146
|
if (!config.isDeleteTaxonRelationships() && (ref instanceof TaxonRelationship)){
|
|
3147
|
if (!config.isDeleteMisappliedNames() &&
|
|
3148
|
(((TaxonRelationship)ref).getType().isMisappliedName())){
|
|
3149
|
message = "The taxon can't be deleted as long as it has misapplied names or invalid designations.";
|
|
3150
|
} else{
|
|
3151
|
message = "The taxon can't be deleted as long as it belongs to taxon relationship.";
|
|
3152
|
}
|
|
3153
|
}
|
|
3154
|
if (ref instanceof PolytomousKeyNode){
|
|
3155
|
message = "The taxon can't be deleted as long as it is referenced by a polytomous key node.";
|
|
3156
|
}
|
|
3157
|
|
|
3158
|
if (HibernateProxyHelper.isInstanceOf(ref, IIdentificationKey.class)){
|
|
3159
|
message = "Taxon can't be deleted as it is used in an identification key. Remove from identification key prior to deleting this taxon";
|
|
3160
|
}
|
|
3161
|
|
|
3162
|
/* //PolytomousKeyNode
|
|
3163
|
if (referencingObject.isInstanceOf(PolytomousKeyNode.class)){
|
|
3164
|
String message = "Taxon" + taxon.getTitleCache() + " can't be deleted as it is used in polytomous key node";
|
|
3165
|
return message;
|
|
3166
|
}*/
|
|
3167
|
|
|
3168
|
//TaxonInteraction
|
|
3169
|
if (ref.isInstanceOf(TaxonInteraction.class)){
|
|
3170
|
message = "Taxon can't be deleted as it is used in taxonInteraction#taxon2";
|
|
3171
|
}
|
|
3172
|
|
|
3173
|
//TaxonInteraction
|
|
3174
|
if (ref.isInstanceOf(DeterminationEvent.class)){
|
|
3175
|
message = "Taxon can't be deleted as it is used in a determination event";
|
|
3176
|
}
|
|
3177
|
}
|
|
3178
|
if (message != null){
|
|
3179
|
result.addException(new ReferencedObjectUndeletableException(message));
|
|
3180
|
result.addRelatedObject(ref);
|
|
3181
|
result.setAbort();
|
|
3182
|
}
|
|
3183
|
}
|
|
3184
|
|
|
3185
|
return result;
|
|
3186
|
}
|
|
3187
|
|
|
3188
|
@Override
|
|
3189
|
public IncludedTaxaDTO listIncludedTaxa(UUID taxonUuid, IncludedTaxonConfiguration config) {
|
|
3190
|
IncludedTaxaDTO result = new IncludedTaxaDTO(taxonUuid);
|
|
3191
|
|
|
3192
|
//preliminary implementation
|
|
3193
|
|
|
3194
|
Set<Taxon> taxa = new HashSet<>();
|
|
3195
|
TaxonBase<?> taxonBase = find(taxonUuid);
|
|
3196
|
if (taxonBase == null){
|
|
3197
|
return new IncludedTaxaDTO();
|
|
3198
|
}else if (taxonBase.isInstanceOf(Taxon.class)){
|
|
3199
|
Taxon taxon = CdmBase.deproxy(taxonBase, Taxon.class);
|
|
3200
|
taxa.add(taxon);
|
|
3201
|
}else if (taxonBase.isInstanceOf(Synonym.class)){
|
|
3202
|
//TODO partial synonyms ??
|
|
3203
|
//TODO synonyms in general
|
|
3204
|
Synonym syn = CdmBase.deproxy(taxonBase, Synonym.class);
|
|
3205
|
taxa.add(syn.getAcceptedTaxon());
|
|
3206
|
}else{
|
|
3207
|
throw new IllegalArgumentException("Unhandled class " + taxonBase.getClass().getSimpleName());
|
|
3208
|
}
|
|
3209
|
|
|
3210
|
Set<Taxon> related = makeRelatedIncluded(taxa, result, config);
|
|
3211
|
int i = 0;
|
|
3212
|
while((! related.isEmpty()) && i++ < 100){ //to avoid
|
|
3213
|
related = makeRelatedIncluded(related, result, config);
|
|
3214
|
}
|
|
3215
|
|
|
3216
|
return result;
|
|
3217
|
}
|
|
3218
|
|
|
3219
|
/**
|
|
3220
|
* @param uncheckedTaxa
|
|
3221
|
* @param existingTaxa
|
|
3222
|
* @param config
|
|
3223
|
*
|
|
3224
|
* Computes all children and conceptually congruent and included taxa and adds them to the existingTaxa
|
|
3225
|
* data structure.
|
|
3226
|
* @return the set of conceptually related taxa for further use
|
|
3227
|
*/
|
|
3228
|
private Set<Taxon> makeRelatedIncluded(Set<Taxon> uncheckedTaxa, IncludedTaxaDTO existingTaxa, IncludedTaxonConfiguration config) {
|
|
3229
|
|
|
3230
|
//children
|
|
3231
|
Set<TaxonNode> taxonNodes = new HashSet<>();
|
|
3232
|
for (Taxon taxon: uncheckedTaxa){
|
|
3233
|
taxonNodes.addAll(taxon.getTaxonNodes());
|
|
3234
|
}
|
|
3235
|
|
|
3236
|
Set<Taxon> children = new HashSet<>();
|
|
3237
|
if (! config.onlyCongruent){
|
|
3238
|
for (TaxonNode node: taxonNodes){
|
|
3239
|
List<TaxonNode> childNodes = nodeService.loadChildNodesOfTaxonNode(node, null, true, config.includeUnpublished, null);
|
|
3240
|
for (TaxonNode child : childNodes){
|
|
3241
|
children.add(child.getTaxon());
|
|
3242
|
}
|
|
3243
|
}
|
|
3244
|
children.remove(null); // just to be on the save side
|
|
3245
|
}
|
|
3246
|
|
|
3247
|
Iterator<Taxon> it = children.iterator();
|
|
3248
|
while(it.hasNext()){
|
|
3249
|
UUID uuid = it.next().getUuid();
|
|
3250
|
if (existingTaxa.contains(uuid)){
|
|
3251
|
it.remove();
|
|
3252
|
}else{
|
|
3253
|
existingTaxa.addIncludedTaxon(uuid, new ArrayList<>(), false);
|
|
3254
|
}
|
|
3255
|
}
|
|
3256
|
|
|
3257
|
//concept relations
|
|
3258
|
Set<Taxon> uncheckedAndChildren = new HashSet<>(uncheckedTaxa);
|
|
3259
|
uncheckedAndChildren.addAll(children);
|
|
3260
|
|
|
3261
|
Set<Taxon> relatedTaxa = makeConceptIncludedTaxa(uncheckedAndChildren, existingTaxa, config);
|
|
3262
|
|
|
3263
|
|
|
3264
|
Set<Taxon> result = new HashSet<>(relatedTaxa);
|
|
3265
|
return result;
|
|
3266
|
}
|
|
3267
|
|
|
3268
|
/**
|
|
3269
|
* Computes all conceptually congruent or included taxa and adds them to the existingTaxa data structure.
|
|
3270
|
* @return the set of these computed taxa
|
|
3271
|
*/
|
|
3272
|
private Set<Taxon> makeConceptIncludedTaxa(Set<Taxon> unchecked, IncludedTaxaDTO existingTaxa, IncludedTaxonConfiguration config) {
|
|
3273
|
Set<Taxon> result = new HashSet<>();
|
|
3274
|
|
|
3275
|
for (Taxon taxon : unchecked){
|
|
3276
|
Set<TaxonRelationship> fromRelations = taxon.getRelationsFromThisTaxon();
|
|
3277
|
Set<TaxonRelationship> toRelations = taxon.getRelationsToThisTaxon();
|
|
3278
|
|
|
3279
|
for (TaxonRelationship fromRel : fromRelations){
|
|
3280
|
if (config.includeDoubtful == false && fromRel.isDoubtful()){
|
|
3281
|
continue;
|
|
3282
|
}
|
|
3283
|
TaxonRelationshipType fromRelType = fromRel.getType();
|
|
3284
|
if (fromRelType.equals(TaxonRelationshipType.CONGRUENT_TO()) ||
|
|
3285
|
!config.onlyCongruent && (
|
|
3286
|
fromRelType.equals(TaxonRelationshipType.INCLUDES()) ||
|
|
3287
|
fromRelType.equals(TaxonRelationshipType.CONGRUENT_OR_INCLUDES())
|
|
3288
|
)
|
|
3289
|
){
|
|
3290
|
result.add(fromRel.getToTaxon());
|
|
3291
|
}
|
|
3292
|
}
|
|
3293
|
|
|
3294
|
for (TaxonRelationship toRel : toRelations){
|
|
3295
|
if (config.includeDoubtful == false && toRel.isDoubtful()){
|
|
3296
|
continue;
|
|
3297
|
}
|
|
3298
|
TaxonRelationshipType fromRelType = toRel.getType();
|
|
3299
|
if (fromRelType.equals(TaxonRelationshipType.CONGRUENT_TO()) ||
|
|
3300
|
!config.includeDoubtful && fromRelType.equals(TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN())){
|
|
3301
|
result.add(toRel.getFromTaxon());
|
|
3302
|
}
|
|
3303
|
}
|
|
3304
|
}
|
|
3305
|
|
|
3306
|
Iterator<Taxon> it = result.iterator();
|
|
3307
|
while(it.hasNext()){
|
|
3308
|
UUID uuid = it.next().getUuid();
|
|
3309
|
if (existingTaxa.contains(uuid)){
|
|
3310
|
it.remove();
|
|
3311
|
}else{
|
|
3312
|
existingTaxa.addIncludedTaxon(uuid, new ArrayList<>(), false);
|
|
3313
|
}
|
|
3314
|
}
|
|
3315
|
return result;
|
|
3316
|
}
|
|
3317
|
|
|
3318
|
@Override
|
|
3319
|
public List<TaxonBase> findTaxaByName(MatchingTaxonConfigurator config){
|
|
3320
|
@SuppressWarnings("rawtypes")
|
|
3321
|
List<TaxonBase> taxonList = dao.getTaxaByName(true, config.isIncludeSynonyms(), false, false, false,
|
|
3322
|
config.getTaxonNameTitle(), null, null, MatchMode.EXACT, null, config.isIncludeSynonyms(), null, 0, 0, config.getPropertyPath());
|
|
3323
|
return taxonList;
|
|
3324
|
}
|
|
3325
|
|
|
3326
|
@Override
|
|
3327
|
@Transactional(readOnly = true)
|
|
3328
|
public <S extends TaxonBase> Pager<IdentifiedEntityDTO<S>> findByIdentifier(
|
|
3329
|
Class<S> clazz, String identifier, DefinedTerm identifierType, TaxonNode subtreeFilter,
|
|
3330
|
MatchMode matchmode, boolean includeEntity, Integer pageSize,
|
|
3331
|
Integer pageNumber, List<String> propertyPaths) {
|
|
3332
|
if (subtreeFilter == null){
|
|
3333
|
return findByIdentifier(clazz, identifier, identifierType, matchmode, includeEntity, pageSize, pageNumber, propertyPaths);
|
|
3334
|
}
|
|
3335
|
|
|
3336
|
long numberOfResults = dao.countByIdentifier(clazz, identifier, identifierType, subtreeFilter, matchmode);
|
|
3337
|
List<Object[]> daoResults = new ArrayList<>();
|
|
3338
|
if(numberOfResults > 0) { // no point checking again
|
|
3339
|
daoResults = dao.findByIdentifier(clazz, identifier, identifierType, subtreeFilter,
|
|
3340
|
matchmode, includeEntity, pageSize, pageNumber, propertyPaths);
|
|
3341
|
}
|
|
3342
|
|
|
3343
|
List<IdentifiedEntityDTO<S>> result = new ArrayList<>();
|
|
3344
|
for (Object[] daoObj : daoResults){
|
|
3345
|
if (includeEntity){
|
|
3346
|
result.add(new IdentifiedEntityDTO<>((DefinedTerm)daoObj[0], (String)daoObj[1], (S)daoObj[2]));
|
|
3347
|
}else{
|
|
3348
|
result.add(new IdentifiedEntityDTO<>((DefinedTerm)daoObj[0], (String)daoObj[1], (UUID)daoObj[2], (String)daoObj[3], null));
|
|
3349
|
}
|
|
3350
|
}
|
|
3351
|
return new DefaultPagerImpl<>(pageNumber, numberOfResults, pageSize, result);
|
|
3352
|
}
|
|
3353
|
|
|
3354
|
@Override
|
|
3355
|
@Transactional(readOnly = true)
|
|
3356
|
public <S extends TaxonBase> Pager<MarkedEntityDTO<S>> findByMarker(
|
|
3357
|
Class<S> clazz, MarkerType markerType, Boolean markerValue,
|
|
3358
|
TaxonNode subtreeFilter, boolean includeEntity, TaxonTitleType titleType,
|
|
3359
|
Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
|
|
3360
|
if (subtreeFilter == null){
|
|
3361
|
return super.findByMarker (clazz, markerType, markerValue, includeEntity, pageSize, pageNumber, propertyPaths);
|
|
3362
|
}
|
|
3363
|
|
|
3364
|
Long numberOfResults = dao.countByMarker(clazz, markerType, markerValue, subtreeFilter);
|
|
3365
|
List<Object[]> daoResults = new ArrayList<>();
|
|
3366
|
if(numberOfResults > 0) { // no point checking again
|
|
3367
|
daoResults = dao.findByMarker(clazz, markerType, markerValue, subtreeFilter,
|
|
3368
|
includeEntity, titleType, pageSize, pageNumber, propertyPaths);
|
|
3369
|
}
|
|
3370
|
|
|
3371
|
List<MarkedEntityDTO<S>> result = new ArrayList<>();
|
|
3372
|
for (Object[] daoObj : daoResults){
|
|
3373
|
if (includeEntity){
|
|
3374
|
result.add(new MarkedEntityDTO<S>((MarkerType)daoObj[0], (Boolean)daoObj[1], (S)daoObj[2]));
|
|
3375
|
}else{
|
|
3376
|
result.add(new MarkedEntityDTO<S>((MarkerType)daoObj[0], (Boolean)daoObj[1], (UUID)daoObj[2], (String)daoObj[3]));
|
|
3377
|
}
|
|
3378
|
}
|
|
3379
|
return new DefaultPagerImpl<>(pageNumber, numberOfResults, pageSize, result);
|
|
3380
|
}
|
|
3381
|
|
|
3382
|
@Override
|
|
3383
|
public UpdateResult moveFactualDateToAnotherTaxon(UUID fromTaxonUuid, UUID toTaxonUuid){
|
|
3384
|
UpdateResult result = new UpdateResult();
|
|
3385
|
|
|
3386
|
Taxon fromTaxon = (Taxon)dao.load(fromTaxonUuid);
|
|
3387
|
Taxon toTaxon = (Taxon) dao.load(toTaxonUuid);
|
|
3388
|
for(TaxonDescription description : fromTaxon.getDescriptions()){
|
|
3389
|
//reload to avoid session conflicts
|
|
3390
|
description = HibernateProxyHelper.deproxy(description, TaxonDescription.class);
|
|
3391
|
|
|
3392
|
String moveMessage = String.format("Description moved from %s", fromTaxon);
|
|
3393
|
if(description.isProtectedTitleCache()){
|
|
3394
|
String separator = "";
|
|
3395
|
if(!StringUtils.isBlank(description.getTitleCache())){
|
|
3396
|
separator = " - ";
|
|
3397
|
}
|
|
3398
|
description.setTitleCache(description.getTitleCache() + separator + moveMessage, true);
|
|
3399
|
}
|
|
3400
|
Annotation annotation = Annotation.NewInstance(moveMessage, Language.getDefaultLanguage());
|
|
3401
|
annotation.setAnnotationType(AnnotationType.TECHNICAL());
|
|
3402
|
description.addAnnotation(annotation);
|
|
3403
|
toTaxon.addDescription(description);
|
|
3404
|
dao.saveOrUpdate(toTaxon);
|
|
3405
|
dao.saveOrUpdate(fromTaxon);
|
|
3406
|
result.addUpdatedObject(toTaxon);
|
|
3407
|
result.addUpdatedObject(fromTaxon);
|
|
3408
|
|
|
3409
|
}
|
|
3410
|
|
|
3411
|
return result;
|
|
3412
|
}
|
|
3413
|
|
|
3414
|
@Override
|
|
3415
|
@Transactional(readOnly = false)
|
|
3416
|
public UpdateResult swapSynonymAndAcceptedTaxon(UUID synonymUUid,
|
|
3417
|
UUID acceptedTaxonUuid, boolean setNameInSource, boolean newUuidForAcceptedTaxon) {
|
|
3418
|
TaxonBase<?> base = this.load(synonymUUid);
|
|
3419
|
Synonym syn = HibernateProxyHelper.deproxy(base, Synonym.class);
|
|
3420
|
base = this.load(acceptedTaxonUuid);
|
|
3421
|
Taxon taxon = HibernateProxyHelper.deproxy(base, Taxon.class);
|
|
3422
|
|
|
3423
|
return this.swapSynonymAndAcceptedTaxon(syn, taxon, setNameInSource, newUuidForAcceptedTaxon);
|
|
3424
|
}
|
|
3425
|
|
|
3426
|
@Override
|
|
3427
|
public TaxonRelationshipsDTO listTaxonRelationships(UUID taxonUuid, Set<TaxonRelationshipType> directTypes,
|
|
3428
|
Set<TaxonRelationshipType> inversTypes,
|
|
3429
|
Direction direction, boolean groupMisapplications,
|
|
3430
|
boolean includeUnpublished,
|
|
3431
|
Integer pageSize, Integer pageNumber) {
|
|
3432
|
TaxonBase<?> taxonBase = dao.load(taxonUuid);
|
|
3433
|
if (taxonBase == null || !taxonBase.isInstanceOf(TaxonBase.class)){
|
|
3434
|
//TODO handle
|
|
3435
|
throw new RuntimeException("Taxon for uuid " + taxonUuid + " not found");
|
|
3436
|
}else{
|
|
3437
|
Taxon taxon = CdmBase.deproxy(taxonBase, Taxon.class);
|
|
3438
|
boolean doDirect = (direction == null || direction == Direction.relatedTo);
|
|
3439
|
boolean doInvers = (direction == null || direction == Direction.relatedFrom);
|
|
3440
|
|
|
3441
|
TaxonRelationshipsDTO dto = new TaxonRelationshipsDTO();
|
|
3442
|
|
|
3443
|
//TODO paging is difficult because misapplication string is an attribute
|
|
3444
|
//of toplevel dto
|
|
3445
|
// long numberOfResults = dao.countTaxonRelationships(taxon, type, includeUnpublished, TaxonRelationship.Direction.relatedFrom);
|
|
3446
|
// List<TaxonRelationshipsDTO> results = new ArrayList<>();
|
|
3447
|
// if(numberOfResults > 0) { // no point checking again
|
|
3448
|
// results = dao.getTaxonRelationships(taxon, type, includeUnpublished, pageSize, pageNumber, orderHints, propertyPaths, TaxonRelationship.Direction.relatedFrom);
|
|
3449
|
// }
|
|
3450
|
//
|
|
3451
|
// return new DefaultPagerImpl<>(pageNumber, numberOfResults, pageSize, results);;
|
|
3452
|
|
|
3453
|
//TODO languages
|
|
3454
|
List<Language> languages = null;
|
|
3455
|
if (doDirect){
|
|
3456
|
direction = Direction.relatedTo;
|
|
3457
|
//TODO order hints, property path
|
|
3458
|
List<TaxonRelationship> relations = dao.getTaxonRelationships(taxon, directTypes, includeUnpublished, pageSize, pageNumber, null, null, direction.invers());
|
|
3459
|
for (TaxonRelationship relation : relations){
|
|
3460
|
dto.addRelation(relation, direction, languages);
|
|
3461
|
}
|
|
3462
|
}
|
|
3463
|
if (doInvers){
|
|
3464
|
direction = Direction.relatedFrom;
|
|
3465
|
//TODO order hints, property path
|
|
3466
|
List<TaxonRelationship> relations = dao.getTaxonRelationships(taxon, inversTypes, includeUnpublished, pageSize, pageNumber, null, null, direction.invers());
|
|
3467
|
for (TaxonRelationship relation : relations){
|
|
3468
|
dto.addRelation(relation, direction, languages);
|
|
3469
|
}
|
|
3470
|
}
|
|
3471
|
if (groupMisapplications){
|
|
3472
|
//TODO
|
|
3473
|
dto.createMisapplicationString();
|
|
3474
|
}
|
|
3475
|
return dto;
|
|
3476
|
}
|
|
3477
|
}
|
|
3478
|
}
|