19 |
19 |
import org.springframework.beans.factory.annotation.Autowired;
|
20 |
20 |
import org.springframework.stereotype.Component;
|
21 |
21 |
|
|
22 |
import eu.etaxonomy.cdm.api.service.dto.CondensedDistribution;
|
22 |
23 |
import eu.etaxonomy.cdm.api.service.pager.Pager;
|
|
24 |
import eu.etaxonomy.cdm.ext.geo.CondensedDistributionRecipe;
|
23 |
25 |
import eu.etaxonomy.cdm.ext.geo.IEditGeoService;
|
24 |
26 |
import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
|
25 |
27 |
import eu.etaxonomy.cdm.model.common.DefinedTermBase;
|
... | ... | |
33 |
35 |
import eu.etaxonomy.cdm.model.name.HomotypicalGroup;
|
34 |
36 |
import eu.etaxonomy.cdm.model.name.HomotypicalGroupComparator;
|
35 |
37 |
import eu.etaxonomy.cdm.model.name.NameRelationship;
|
|
38 |
import eu.etaxonomy.cdm.model.name.NameRelationshipType;
|
36 |
39 |
import eu.etaxonomy.cdm.model.name.NameTypeDesignation;
|
37 |
40 |
import eu.etaxonomy.cdm.model.name.NameTypeDesignationStatus;
|
|
41 |
import eu.etaxonomy.cdm.model.name.NomenclaturalStatus;
|
|
42 |
import eu.etaxonomy.cdm.model.name.NonViralName;
|
38 |
43 |
import eu.etaxonomy.cdm.model.name.Rank;
|
39 |
44 |
import eu.etaxonomy.cdm.model.name.TaxonNameBase;
|
40 |
45 |
import eu.etaxonomy.cdm.model.name.TypeDesignationBase;
|
|
46 |
import eu.etaxonomy.cdm.model.reference.Reference;
|
41 |
47 |
import eu.etaxonomy.cdm.model.taxon.Classification;
|
42 |
48 |
import eu.etaxonomy.cdm.model.taxon.HomotypicGroupTaxonComparator;
|
43 |
49 |
import eu.etaxonomy.cdm.model.taxon.Synonym;
|
44 |
50 |
import eu.etaxonomy.cdm.model.taxon.SynonymRelationship;
|
45 |
|
import eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType;
|
46 |
51 |
import eu.etaxonomy.cdm.model.taxon.Taxon;
|
47 |
52 |
import eu.etaxonomy.cdm.model.taxon.TaxonBase;
|
48 |
|
import eu.etaxonomy.cdm.model.taxon.TaxonComparator;
|
49 |
53 |
import eu.etaxonomy.cdm.model.taxon.TaxonNode;
|
|
54 |
import eu.etaxonomy.cdm.model.taxon.TaxonRelationship;
|
|
55 |
import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;
|
50 |
56 |
import eu.etaxonomy.cdm.persistence.query.MatchMode;
|
51 |
57 |
|
52 |
58 |
|
... | ... | |
168 |
174 |
|
169 |
175 |
childrenNodes = getTaxonNodeService().find(childrenUuids);
|
170 |
176 |
for(TaxonNode genusNode : childrenNodes) {
|
171 |
|
if (!genusNode.isTopmostNode()){
|
172 |
|
nameRecords.add(createNewRecord(genusNode, state));
|
173 |
|
}
|
|
177 |
|
|
178 |
nameRecords.add(createNewRecord(genusNode, state));
|
|
179 |
|
174 |
180 |
refreshTransaction();
|
175 |
181 |
|
176 |
182 |
}
|
... | ... | |
195 |
201 |
for (TaxonNode child: familyNode.getChildNodes()){
|
196 |
202 |
child = HibernateProxyHelper.deproxy(child, TaxonNode.class);
|
197 |
203 |
name = HibernateProxyHelper.deproxy(child.getTaxon().getName(), TaxonNameBase.class);
|
198 |
|
if (name.isGenus()) {
|
|
204 |
if (child.getTaxon().getName().getRank().isLower(Rank.GENUS()) || child.getTaxon().getName().isGenus()) {
|
199 |
205 |
childrenUuids.add(child.getUuid());
|
200 |
206 |
if (child.hasChildNodes()){
|
201 |
207 |
parentsNodesUUID.add(child.getUuid());
|
202 |
208 |
}
|
|
209 |
}else{
|
|
210 |
parentsNodesUUID.add(child.getUuid());
|
203 |
211 |
}
|
204 |
212 |
}
|
205 |
213 |
//refreshTransaction();
|
... | ... | |
213 |
221 |
|
214 |
222 |
|
215 |
223 |
|
216 |
|
private String createSynonymNameString(BotanicalName synonymName) {
|
|
224 |
private String createSynonymNameString(BotanicalName synonymName, boolean isInvalid) {
|
217 |
225 |
String synonymString = null;
|
218 |
226 |
|
219 |
|
synonymString = synonymName.generateFullTitle();
|
220 |
|
if (synonymName.getNameCache() != null){
|
221 |
|
synonymString = synonymString.replaceAll(synonymName.getNameCache(), "<i>"+ synonymName.getNameCache() + "</i>");
|
222 |
|
} else{
|
223 |
|
if (synonymName.getGenusOrUninomial() != null){
|
224 |
|
synonymString = synonymString.replaceAll(synonymName.getGenusOrUninomial(), "<i>"+ synonymName.getGenusOrUninomial() + "</i>");
|
225 |
|
}
|
226 |
|
if (synonymName.getInfraGenericEpithet() != null){
|
227 |
|
synonymString = synonymString.replaceAll(synonymName.getInfraGenericEpithet(), "<i>"+ synonymName.getInfraGenericEpithet() + "</i>");
|
228 |
|
}
|
229 |
|
if (synonymName.getSpecificEpithet() != null){
|
230 |
|
synonymString = synonymString.replaceAll(synonymName.getSpecificEpithet(), "<i>"+ synonymName.getSpecificEpithet() + "</i>");
|
|
227 |
synonymString= createTaggedNameString(synonymName, isInvalid);
|
|
228 |
Set<NameRelationship> nameRelations = synonymName.getNameRelations();
|
|
229 |
|
|
230 |
NonViralName relatedName = null;
|
|
231 |
String nameRelType = null;
|
|
232 |
boolean first = true;
|
|
233 |
boolean isInvalidRel = false;
|
|
234 |
for (NameRelationship nameRel: nameRelations){
|
|
235 |
// NameRelationship nameRel = nameRelations.iterator().next();
|
|
236 |
BotanicalName fromName = HibernateProxyHelper.deproxy(nameRel.getFromName(), BotanicalName.class);
|
|
237 |
|
|
238 |
nameRel = HibernateProxyHelper.deproxy(nameRel, NameRelationship.class);
|
|
239 |
nameRelType = nameRel.getType().getTitleCache();
|
|
240 |
String relatedNameString = "";
|
|
241 |
if (fromName.equals(synonymName)){
|
|
242 |
relatedName = HibernateProxyHelper.deproxy(nameRel.getToName(), NonViralName.class);
|
|
243 |
|
|
244 |
}else{
|
|
245 |
relatedName = HibernateProxyHelper.deproxy(nameRel.getFromName(), NonViralName.class);
|
231 |
246 |
}
|
232 |
|
if (synonymName.getInfraSpecificEpithet() != null){
|
233 |
|
synonymString = synonymString.replaceAll(synonymName.getInfraSpecificEpithet(), "<i>"+ synonymName.getInfraSpecificEpithet() + "</i>");
|
|
247 |
if (!nameRel.getType().equals(NameRelationshipType.BASIONYM())){
|
|
248 |
isInvalidRel = getStatus(relatedName);
|
|
249 |
relatedNameString = createTaggedNameString(relatedName, isInvalidRel);
|
|
250 |
|
|
251 |
if (nameRel.getType().equals(NameRelationshipType.LATER_HOMONYM())){
|
|
252 |
if (synonymName.equals(nameRel.getFromName())){
|
|
253 |
if (first){
|
|
254 |
synonymString = synonymString + " [non " + relatedNameString ;
|
|
255 |
first = false;
|
|
256 |
} else{
|
|
257 |
synonymString = synonymString + " nec " + relatedNameString ;
|
|
258 |
}
|
|
259 |
}
|
|
260 |
} else if (nameRel.getType().equals(NameRelationshipType.REPLACED_SYNONYM())){
|
|
261 |
//synonymString = synonymString + " [non " + relatedNameString + "]";
|
|
262 |
} else if (nameRel.getType().equals(NameRelationshipType.BLOCKING_NAME_FOR())){
|
|
263 |
if (synonymName.equals(nameRel.getToName())){
|
|
264 |
if (first){
|
|
265 |
synonymString = synonymString + " [non " + relatedNameString ;
|
|
266 |
first = false;
|
|
267 |
} else{
|
|
268 |
synonymString = synonymString + " nec " + relatedNameString ;
|
|
269 |
}
|
|
270 |
|
|
271 |
}
|
|
272 |
} else if (nameRel.getType().equals(NameRelationshipType.TREATED_AS_LATER_HOMONYM())){
|
|
273 |
if (first){
|
|
274 |
synonymString = synonymString + " [non " + relatedNameString ;
|
|
275 |
first = false;
|
|
276 |
} else{
|
|
277 |
synonymString = synonymString + " nec " + relatedNameString ;
|
|
278 |
}
|
|
279 |
} else if (nameRel.getType().equals(NameRelationshipType.ALTERNATIVE_NAME())){
|
|
280 |
if (first){
|
|
281 |
synonymString = synonymString + " [non " + relatedNameString ;
|
|
282 |
first = false;
|
|
283 |
} else{
|
|
284 |
synonymString = synonymString + " nec " + relatedNameString ;
|
|
285 |
}
|
|
286 |
} else if (nameRel.getType().equals(NameRelationshipType.CONSERVED_AGAINST())) {
|
|
287 |
|
|
288 |
}else if (nameRel.getType().equals(NameRelationshipType.ORTHOGRAPHIC_VARIANT())){
|
|
289 |
|
|
290 |
}
|
|
291 |
|
|
292 |
|
234 |
293 |
}
|
235 |
294 |
}
|
|
295 |
if (!first){
|
|
296 |
synonymString = synonymString + "]";
|
|
297 |
}
|
|
298 |
|
236 |
299 |
|
237 |
300 |
|
238 |
301 |
return synonymString;
|
239 |
302 |
}
|
240 |
303 |
|
|
304 |
/**
|
|
305 |
* @param relatedName
|
|
306 |
* @return
|
|
307 |
*/
|
|
308 |
private boolean getStatus(NonViralName relatedName) {
|
|
309 |
boolean result;
|
|
310 |
if (!relatedName.getStatus().isEmpty()){
|
|
311 |
NomenclaturalStatus status = HibernateProxyHelper.deproxy(relatedName.getStatus().iterator().next(),NomenclaturalStatus.class);
|
|
312 |
if (status.getType().isInvalidType()){
|
|
313 |
result = true;
|
|
314 |
}else{
|
|
315 |
result = false;
|
|
316 |
}
|
|
317 |
}else{
|
|
318 |
result = false;
|
|
319 |
}
|
|
320 |
return result;
|
|
321 |
}
|
|
322 |
|
|
323 |
private String createTaggedNameString(NonViralName name, boolean isInvalid){
|
|
324 |
String nameString = null;
|
|
325 |
if (name == null){
|
|
326 |
return nameString;
|
|
327 |
}
|
|
328 |
|
|
329 |
nameString = name.generateFullTitle();
|
|
330 |
if (isInvalid){
|
|
331 |
nameString = nameString.replace(name.getTitleCache(), "\""+name.getTitleCache()+"\"");
|
|
332 |
}
|
|
333 |
if (name.getGenusOrUninomial() != null){
|
|
334 |
nameString = nameString.replaceAll(name.getGenusOrUninomial(), "<i>"+ name.getGenusOrUninomial() + "</i>");
|
|
335 |
}
|
|
336 |
if (name.getInfraGenericEpithet() != null){
|
|
337 |
nameString = nameString.replaceAll(name.getInfraGenericEpithet(), "<i>"+ name.getInfraGenericEpithet() + "</i>");
|
|
338 |
}
|
|
339 |
if (name.getSpecificEpithet() != null){
|
|
340 |
nameString = nameString.replaceAll(name.getSpecificEpithet(), "<i>"+ name.getSpecificEpithet() + "</i>");
|
|
341 |
}
|
|
342 |
if (name.getInfraSpecificEpithet() != null && !name.isAutonym()){
|
|
343 |
nameString = nameString.replaceAll(name.getInfraSpecificEpithet(), "<i>"+ name.getInfraSpecificEpithet() + "</i>");
|
|
344 |
}
|
|
345 |
|
|
346 |
return nameString;
|
|
347 |
}
|
|
348 |
|
241 |
349 |
|
242 |
350 |
|
243 |
351 |
private List<TaxonNode> getGenusNodes (UUID classificationUUID){
|
... | ... | |
267 |
375 |
|
268 |
376 |
private TaxonNode getHigherNode(TaxonNode node, Rank rank){
|
269 |
377 |
|
270 |
|
node = HibernateProxyHelper.deproxy(node, TaxonNode.class);
|
271 |
|
TaxonNameBase name = HibernateProxyHelper.deproxy( node.getTaxon().getName(), TaxonNameBase.class);
|
272 |
378 |
Rank nodeRank = node.getTaxon().getName().getRank();
|
273 |
|
if (nodeRank.equals(rank)){
|
|
379 |
if (nodeRank.isKindOf(rank)){
|
274 |
380 |
return node;
|
275 |
381 |
|
276 |
382 |
}else if (nodeRank.isHigher(rank)){
|
... | ... | |
284 |
390 |
StringBuffer descriptionsString = new StringBuffer();
|
285 |
391 |
TextData textElement;
|
286 |
392 |
Set<Distribution> distributions = new HashSet<Distribution>();
|
|
393 |
if (taxon.getDescriptions().isEmpty()){
|
|
394 |
nameRecord.put(columnName, null);
|
|
395 |
return;
|
|
396 |
}
|
287 |
397 |
for (DescriptionBase<?> descriptionBase: taxon.getDescriptions()){
|
288 |
398 |
|
289 |
399 |
Set<DescriptionElementBase> elements = descriptionBase.getElements();
|
... | ... | |
307 |
417 |
|
308 |
418 |
|
309 |
419 |
}
|
310 |
|
// Collections.sort(distributions, new DistributionNodeByAreaLabelComparator());
|
311 |
|
|
312 |
420 |
if (state.getConfig().isCondensedDistribution()){
|
313 |
421 |
List<Language> langs = new ArrayList<Language>();
|
314 |
422 |
langs.add(Language.ENGLISH());
|
315 |
423 |
|
316 |
424 |
|
317 |
|
// CondensedDistribution conDis = geoService.getCondensedDistribution(distributions, true, null,null,CondensedDistributionRecipe.FloraCuba, langs );
|
318 |
|
//
|
319 |
|
// nameRecord.put(columnName, conDis.toString());
|
|
425 |
CondensedDistribution conDis = geoService.getCondensedDistribution(distributions, true, null,null,CondensedDistributionRecipe.FloraCuba, langs );
|
|
426 |
|
|
427 |
nameRecord.put(columnName, conDis.toString());
|
320 |
428 |
|
321 |
429 |
} else{
|
322 |
430 |
for (Distribution distribution:distributions){
|
... | ... | |
327 |
435 |
descriptionsString.append(distribution.getArea().getIdInVocabulary());
|
328 |
436 |
|
329 |
437 |
}
|
330 |
|
|
|
438 |
nameRecord.put(columnName, descriptionsString.toString());
|
331 |
439 |
}
|
332 |
|
nameRecord.put(columnName, descriptionsString.toString());
|
333 |
440 |
|
334 |
441 |
}
|
335 |
442 |
|
... | ... | |
358 |
465 |
nameRecord.put("classification", childNode.getClassification().getTitleCache());
|
359 |
466 |
TaxonNode familyNode = getHigherNode(childNode, Rank.FAMILY());
|
360 |
467 |
Taxon taxon;
|
|
468 |
String nameString;
|
361 |
469 |
BotanicalName name;
|
362 |
|
if (familyNode != null){
|
|
470 |
if (familyNode == null){
|
|
471 |
nameRecord.put("familyTaxon", null);
|
|
472 |
nameRecord.put("familyName", null);
|
|
473 |
nameRecord.put("descriptionsFam", null);
|
|
474 |
}else{
|
363 |
475 |
familyNode = HibernateProxyHelper.deproxy(familyNode, TaxonNode.class);
|
364 |
476 |
familyNode.getTaxon().setProtectedTitleCache(true);
|
365 |
|
|
366 |
477 |
nameRecord.put("familyTaxon", familyNode.getTaxon().getTitleCache());
|
367 |
478 |
|
368 |
|
|
369 |
|
|
370 |
|
|
371 |
479 |
taxon = (Taxon)getTaxonService().load(familyNode.getTaxon().getUuid());
|
372 |
480 |
taxon = HibernateProxyHelper.deproxy(taxon, Taxon.class);
|
373 |
481 |
//if publish flag is set
|
... | ... | |
376 |
484 |
name = HibernateProxyHelper.deproxy(taxon.getName(), BotanicalName.class);
|
377 |
485 |
nameRecord.put("familyName", name.getNameCache());
|
378 |
486 |
extractDescriptions(nameRecord, taxon, Feature.INTRODUCTION(), "descriptionsFam", state);
|
379 |
|
} else{
|
380 |
|
nameRecord.put("familyTaxon", null);
|
381 |
|
nameRecord.put("familyName", null);
|
382 |
|
nameRecord.put("descriptionsFam", null);
|
383 |
487 |
}
|
384 |
488 |
TaxonNode genusNode = getHigherNode(childNode, Rank.GENUS());
|
385 |
489 |
if (genusNode!= null){
|
... | ... | |
398 |
502 |
}else{
|
399 |
503 |
nameRecord.put("genusName", name.getGenusOrUninomial());
|
400 |
504 |
}
|
401 |
|
extractDescriptions(nameRecord, taxon, getNotesFeature(state), "descriptionsGen", state);
|
|
505 |
extractDescriptions(nameRecord, taxon,getNotesFeature(state), "descriptionsGen", state);
|
|
506 |
}else{
|
|
507 |
nameRecord.put("genusTaxon", null);
|
|
508 |
nameRecord.put("genusName", null);
|
|
509 |
nameRecord.put("descriptionsGen", null);
|
402 |
510 |
}
|
403 |
511 |
taxon = (Taxon) getTaxonService().load(childNode.getTaxon().getUuid());
|
404 |
512 |
taxon = HibernateProxyHelper.deproxy(taxon, Taxon.class);
|
405 |
513 |
// if (taxon.isPublish()){
|
|
514 |
|
|
515 |
NonViralName nonViralName = HibernateProxyHelper.deproxy(taxon.getName(), NonViralName.class);
|
|
516 |
|
|
517 |
nameString = createTaggedNameString(nonViralName, false);
|
406 |
518 |
nameRecord.put("childTaxon", taxon.getTitleCache());
|
407 |
519 |
if (taxon.getSec()!= null){
|
408 |
520 |
nameRecord.put("secRef", taxon.getSec().getTitleCache());
|
... | ... | |
410 |
522 |
nameRecord.put("secRef", null);
|
411 |
523 |
}
|
412 |
524 |
|
|
525 |
getTaxonRelations(nameRecord, taxon);
|
|
526 |
|
413 |
527 |
name = HibernateProxyHelper.deproxy(getNameService().load(taxon.getName().getUuid()), BotanicalName.class);
|
414 |
|
nameRecord.put("childName",name.getTitleCache());
|
|
528 |
nameRecord.put("childName",nameString);
|
415 |
529 |
nameRecord.put("nameId", String.valueOf(name.getId()));
|
416 |
530 |
nameRecord.put("nameCache", name.getNameCache());
|
417 |
531 |
nameRecord.put("titleName", name.getTitleCache());
|
... | ... | |
444 |
558 |
nameRecord.put("typeName", typeNameString);
|
445 |
559 |
StringBuffer homotypicalSynonyms = new StringBuffer();
|
446 |
560 |
TreeMap<HomotypicalGroup,List<Synonym>> heterotypicSynonymsList = new TreeMap<HomotypicalGroup,List<Synonym>>(new HomotypicalGroupComparator());
|
|
561 |
|
447 |
562 |
List<Synonym> homotypicSynonymsList = new ArrayList<Synonym>();
|
448 |
563 |
StringBuffer heterotypicalSynonyms = new StringBuffer();
|
449 |
564 |
List<Synonym> homotypicSynonyms;
|
... | ... | |
453 |
568 |
String doubtfulTitleCache;
|
454 |
569 |
for (SynonymRelationship synRel: taxon.getSynonymRelations()){
|
455 |
570 |
synonymName = HibernateProxyHelper.deproxy(synRel.getSynonym().getName(), BotanicalName.class);
|
456 |
|
if (synRel.getType().equals(SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF())){
|
457 |
|
group = HibernateProxyHelper.deproxy(synonymName.getHomotypicalGroup(), HomotypicalGroup.class);
|
458 |
|
synonymName.generateFullTitle();
|
459 |
|
if (synRel.getSynonym().isDoubtful()){
|
|
571 |
group = HibernateProxyHelper.deproxy(synonymName.getHomotypicalGroup(), HomotypicalGroup.class);
|
|
572 |
synonymName.generateFullTitle();
|
|
573 |
if (synRel.getSynonym().isDoubtful()){
|
|
574 |
if (!synonymName.getFullTitleCache().startsWith("?")){
|
460 |
575 |
doubtfulTitleCache = "?" + synonymName.getFullTitleCache();
|
|
576 |
synonymName = (BotanicalName) synonymName.clone();
|
461 |
577 |
synonymName.setFullTitleCache(doubtfulTitleCache, true);
|
462 |
578 |
}
|
|
579 |
}
|
|
580 |
if (!group.equals(name.getHomotypicalGroup())){
|
463 |
581 |
if (heterotypicSynonymsList.containsKey(group)){
|
464 |
582 |
heterotypicSynonymsList.get(group).add(synRel.getSynonym());
|
465 |
583 |
}else{
|
... | ... | |
483 |
601 |
Collections.sort(list, new HomotypicGroupTaxonComparator(null));
|
484 |
602 |
first = true;
|
485 |
603 |
for (TaxonBase<?> synonym : list){
|
|
604 |
NomenclaturalStatus status = null;
|
|
605 |
if (!synonym.getName().getStatus().isEmpty()){
|
|
606 |
status = HibernateProxyHelper.deproxy(synonym.getName().getStatus().iterator().next(),NomenclaturalStatus.class);
|
|
607 |
if (status.getType().isInvalidType()){
|
|
608 |
heterotypicalSynonyms.append(" <invalid> ");
|
|
609 |
synonymName = HibernateProxyHelper.deproxy(synonym.getName(), BotanicalName.class);
|
|
610 |
|
|
611 |
synonymString = createSynonymNameString(synonymName, state.getConfig().isInvalidNamesQuoted()) ;
|
|
612 |
heterotypicalSynonyms.append(synonymString);
|
|
613 |
continue;
|
|
614 |
}
|
|
615 |
}
|
486 |
616 |
if (first){
|
487 |
617 |
heterotypicalSynonyms.append(" <heterotypic> ");
|
488 |
618 |
}else{
|
... | ... | |
490 |
620 |
}
|
491 |
621 |
first = false;
|
492 |
622 |
synonymName = HibernateProxyHelper.deproxy(synonym.getName(), BotanicalName.class);
|
493 |
|
synonymString = createSynonymNameString(synonymName);
|
|
623 |
synonymString = createSynonymNameString(synonymName, false);
|
494 |
624 |
heterotypicalSynonyms.append(synonymString);
|
495 |
625 |
}
|
496 |
626 |
}
|
497 |
627 |
|
498 |
628 |
first = true;
|
499 |
|
Collections.sort(homotypicSynonymsList, new TaxonComparator());
|
|
629 |
Collections.sort(homotypicSynonymsList, new HomotypicGroupTaxonComparator(null) );
|
|
630 |
NomenclaturalStatus status = null;
|
500 |
631 |
for (TaxonBase<?> synonym : homotypicSynonymsList){
|
501 |
|
if (!first){
|
|
632 |
|
|
633 |
if (!synonym.getName().getStatus().isEmpty()){
|
|
634 |
status = HibernateProxyHelper.deproxy(synonym.getName().getStatus().iterator().next(),NomenclaturalStatus.class);
|
|
635 |
if (status.getType().isInvalidType()){
|
|
636 |
homotypicalSynonyms.append(" <invalid> ");
|
|
637 |
synonymName = HibernateProxyHelper.deproxy(synonym.getName(), BotanicalName.class);
|
|
638 |
synonymString = createSynonymNameString(synonymName, true);
|
|
639 |
homotypicalSynonyms.append(synonymString);
|
|
640 |
continue;
|
|
641 |
}else if (!first){
|
|
642 |
homotypicalSynonyms.append(" <homonym> ");
|
|
643 |
}
|
|
644 |
|
|
645 |
}else if (!first){
|
502 |
646 |
homotypicalSynonyms.append(" <homonym> ");
|
503 |
647 |
}
|
504 |
648 |
first = false;
|
505 |
649 |
synonymName = HibernateProxyHelper.deproxy(synonym.getName(), BotanicalName.class);
|
506 |
|
synonymString = createSynonymNameString(synonymName);
|
|
650 |
|
|
651 |
synonymString = createSynonymNameString(synonymName, false);
|
507 |
652 |
|
508 |
653 |
homotypicalSynonyms.append(synonymString);
|
509 |
654 |
|
... | ... | |
515 |
660 |
|
516 |
661 |
Set<NameRelationship> nameRelations = name.getNameRelations();
|
517 |
662 |
|
518 |
|
String relatedName = null;
|
|
663 |
NonViralName relatedName = null;
|
519 |
664 |
String nameRelType = null;
|
|
665 |
String relNameString = null;
|
520 |
666 |
if (nameRelations.size()>0){
|
521 |
667 |
NameRelationship nameRel = nameRelations.iterator().next();
|
522 |
668 |
BotanicalName fromName = HibernateProxyHelper.deproxy(nameRel.getFromName(), BotanicalName.class);
|
523 |
669 |
if (fromName.equals(taxon.getName())){
|
524 |
|
relatedName = nameRel.getToName().getTitleCache();
|
|
670 |
relatedName = HibernateProxyHelper.deproxy(nameRel.getToName(), NonViralName.class);
|
525 |
671 |
|
526 |
672 |
}else{
|
527 |
|
relatedName = nameRel.getFromName().getTitleCache();
|
|
673 |
relatedName = HibernateProxyHelper.deproxy(nameRel.getFromName(), NonViralName.class);
|
528 |
674 |
}
|
529 |
675 |
nameRel = HibernateProxyHelper.deproxy(nameRel, NameRelationship.class);
|
530 |
676 |
nameRelType = nameRel.getType().getTitleCache();
|
|
677 |
relNameString = createTaggedNameString(relatedName, getStatus(relatedName));
|
531 |
678 |
}
|
532 |
679 |
|
533 |
680 |
|
534 |
|
nameRecord.put("relatedName", relatedName);
|
|
681 |
nameRecord.put("relatedName", relNameString);
|
535 |
682 |
nameRecord.put("nameRelType", nameRelType);
|
536 |
683 |
|
537 |
|
extractDescriptions(nameRecord, taxon, Feature.DISTRIBUTION(), "description", state);
|
|
684 |
extractDescriptions(nameRecord, taxon, Feature.DISTRIBUTION(), "descriptions", state);
|
538 |
685 |
return nameRecord;
|
539 |
686 |
}
|
540 |
687 |
|
|
688 |
/**
|
|
689 |
* @param nameRecord
|
|
690 |
* @param taxon
|
|
691 |
*/
|
|
692 |
private void getTaxonRelations(HashMap<String, String> nameRecord, Taxon taxon) {
|
|
693 |
Set<TaxonRelationship> relations = new HashSet<TaxonRelationship>();
|
|
694 |
relations =taxon.getTaxonRelations();
|
|
695 |
if (relations.isEmpty()){
|
|
696 |
nameRecord.put("missappliedNames", null);
|
|
697 |
}else{
|
|
698 |
Taxon relatedTaxon = null;
|
|
699 |
StringBuffer nameString = new StringBuffer();
|
|
700 |
for (TaxonRelationship rel : relations){
|
|
701 |
if (rel.getType().equals(TaxonRelationshipType.MISAPPLIED_NAME_FOR())){
|
|
702 |
relatedTaxon = rel.getFromTaxon();
|
|
703 |
Reference secRef = relatedTaxon.getSec();
|
|
704 |
String appendedPhrase = "";
|
|
705 |
if (relatedTaxon.getAppendedPhrase() != null){
|
|
706 |
appendedPhrase = relatedTaxon.getAppendedPhrase();
|
|
707 |
}
|
|
708 |
if (secRef == null){
|
|
709 |
nameString.append("<misapplied>\"" + createTaggedNameString(HibernateProxyHelper.deproxy(relatedTaxon.getName(), NonViralName.class), false) + "\" " + appendedPhrase);
|
|
710 |
} else if (secRef.getAuthorship() == null){
|
|
711 |
nameString.append("<misapplied>\"" + createTaggedNameString(HibernateProxyHelper.deproxy(relatedTaxon.getName(), NonViralName.class), false) + "\" " + appendedPhrase + " sensu " + secRef.getTitleCache());
|
|
712 |
} else {
|
|
713 |
nameString.append("<misapplied>\"" + createTaggedNameString(HibernateProxyHelper.deproxy(relatedTaxon.getName(), NonViralName.class), false) + "\" " + appendedPhrase + " sensu " + secRef.getAuthorship().getNomenclaturalTitle());
|
|
714 |
}
|
|
715 |
|
|
716 |
}
|
|
717 |
}
|
|
718 |
nameRecord.put("missappliedNames", nameString.toString());
|
|
719 |
}
|
|
720 |
|
|
721 |
}
|
|
722 |
|
541 |
723 |
|
542 |
724 |
}
|
543 |
725 |
|
make the csv export more configurable