Project

General

Profile

« Previous | Next » 

Revision aad95ea0

Added by Katja Luther almost 8 years ago

make the csv export more configurable

View differences:

cdmlib-io/src/main/java/eu/etaxonomy/cdm/io/csv/caryophyllales/out/CsvNameExport.java
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

  
cdmlib-io/src/main/java/eu/etaxonomy/cdm/io/csv/caryophyllales/out/CsvNameExportConfigurator.java
23 23
	private String fieldsTerminatedBy=";";
24 24
	private boolean namesOnly = false;
25 25
	private UUID classificationUUID;
26

  
27
	private boolean condensedDistribution = true;
26
	private boolean condensedDistribution = false;
27
	private boolean invalidNamesQuoted = false;
28 28

  
29 29

  
30 30
    private Rank rank = Rank.GENUS();
......
143 143
        this.condensedDistribution = condensedDistribution;
144 144
    }
145 145

  
146
    /**
147
     * @return the invalidNamesQuoted
148
     */
149
    public boolean isInvalidNamesQuoted() {
150
        return invalidNamesQuoted;
151
    }
152

  
153
    /**
154
     * @param invalidNamesQuoted the invalidNamesQuoted to set
155
     */
156
    public void setInvalidNamesQuoted(boolean invalidNamesQuoted) {
157
        this.invalidNamesQuoted = invalidNamesQuoted;
158
    }
159

  
146 160

  
147 161
}

Also available in: Unified diff