import eu.etaxonomy.cdm.common.CdmUtils;
import eu.etaxonomy.cdm.io.common.TdwgAreaProvider;
import eu.etaxonomy.cdm.io.excel.common.ExcelRowBase.SourceDataHolder;
+import eu.etaxonomy.cdm.io.tcsrdf.TcsRdfTransformer;
import eu.etaxonomy.cdm.model.agent.Team;
import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase;
import eu.etaxonomy.cdm.model.common.CdmBase;
import eu.etaxonomy.cdm.model.description.TextData;
import eu.etaxonomy.cdm.model.location.NamedArea;
import eu.etaxonomy.cdm.model.media.Media;
+import eu.etaxonomy.cdm.model.name.BotanicalName;
+import eu.etaxonomy.cdm.model.name.NameRelationshipType;
import eu.etaxonomy.cdm.model.name.NomenclaturalCode;
import eu.etaxonomy.cdm.model.name.NomenclaturalStatusType;
import eu.etaxonomy.cdm.model.name.NonViralName;
import eu.etaxonomy.cdm.model.name.Rank;
import eu.etaxonomy.cdm.model.name.TaxonNameBase;
+import eu.etaxonomy.cdm.model.name.ZoologicalName;
import eu.etaxonomy.cdm.model.reference.INomenclaturalReference;
import eu.etaxonomy.cdm.model.reference.Reference;
import eu.etaxonomy.cdm.model.reference.ReferenceFactory;
String value = keyValue.value;
Integer index = keyValue.index;
if (((NormalExplicitImportConfigurator)state.getConfig()).getParentUUID() != null){
- normalExplicitRow.setParentId(0);
+ normalExplicitRow.setParentId("0");
}
key = key.replace(" ","");
if (key.equalsIgnoreCase(ID_COLUMN)) {
- int ivalue = floatString2IntValue(value);
- normalExplicitRow.setId(ivalue);
+ //String ivalue = floatString2IntValue(value);
+ normalExplicitRow.setId(value);
} else if(key.equalsIgnoreCase(PARENT_ID_COLUMN) ) {
- int ivalue = floatString2IntValue(value);
- normalExplicitRow.setParentId(ivalue);
+ //int ivalue = floatString2IntValue(value);
+ normalExplicitRow.setParentId(value);
} else if(key.equalsIgnoreCase(RANK_COLUMN)) {
normalExplicitRow.setRank(value);
- } else if(key.trim().equalsIgnoreCase(SCIENTIFIC_NAME_COLUMN)) {
+ } else if(key.trim().equalsIgnoreCase(SCIENTIFIC_NAME_COLUMN) || key.trim().equalsIgnoreCase(FULLNAME_COLUMN)) {
normalExplicitRow.setScientificName(value);
- } else if(key.equalsIgnoreCase(AUTHOR_COLUMN)) {
+ } else if(key.equalsIgnoreCase(AUTHOR_COLUMN)|| key.equalsIgnoreCase(AUTHORS_COLUMN)) {
normalExplicitRow.setAuthor(value);
-
- } else if(key.equalsIgnoreCase(REFERENCE_COLUMN)) {
+ }else if(key.equalsIgnoreCase(PUBLISHING_AUTHOR_COLUMN)) {
+ normalExplicitRow.setPublishingAuthor(value);
+ }else if(key.equalsIgnoreCase(BASIONYM_AUTHOR_COLUMN)) {
+ normalExplicitRow.setBasionymAuthor(value);
+
+ }else if(key.equalsIgnoreCase(BASIONYM_COLUMN)) {
+ normalExplicitRow.setBasionym(value);
+ }else if(key.trim().equalsIgnoreCase(NOMENCLATURAL_SYNONYM_COLUMN)) {
+ normalExplicitRow.setSynonym(value);
+ } else if(key.equalsIgnoreCase(REFERENCE_COLUMN) || key.equalsIgnoreCase(PUBLICATION_COLUMN)) {
normalExplicitRow.setReference(value);
- } else if(key.equalsIgnoreCase(NAME_STATUS_COLUMN) ) {
+ } else if(key.equalsIgnoreCase(COLLATION_COLUMN)) {
+ normalExplicitRow.setCollation(value);
+
+ }else if(key.equalsIgnoreCase(NAMESTATUS_COLUMN)) {
normalExplicitRow.setNameStatus(value);
} else if(key.equalsIgnoreCase(VERNACULAR_NAME_COLUMN)) {
} else if(key.equalsIgnoreCase(LANGUAGE_COLUMN)) {
normalExplicitRow.setLanguage(value);
- } else if(key.equalsIgnoreCase(TDWG_COLUMN)) {
+ } else if(key.equalsIgnoreCase(TDWG_COLUMN) ) {
//TODO replace still necessary?
value = value.replace(".0", "");
normalExplicitRow.putDistribution(index, value);
} else if(key.equalsIgnoreCase(IMAGE_COLUMN)) {
normalExplicitRow.putImage(index, value);
- } else if(key.equalsIgnoreCase(DATE_COLUMN) || key.equalsIgnoreCase(YEAR_COLUMN)) {
+ } else if(key.equalsIgnoreCase(DATE_COLUMN) || key.equalsIgnoreCase(YEAR_COLUMN)|| key.equalsIgnoreCase(PUBLICATION_YEAR_COLUMN)) {
normalExplicitRow.setDate(value);
} else if(key.equalsIgnoreCase(FAMILY_COLUMN)) {
normalExplicitRow.setFamily(value);
- }else if(key.equalsIgnoreCase("!")) {
+ } else if(key.equalsIgnoreCase(INFRA_FAMILY_COLUMN)) {
+ normalExplicitRow.setInfraFamily(value);
+ }else if(key.equalsIgnoreCase(GENUS_COLUMN)) {
+ normalExplicitRow.setGenus(value);
+ }else if(key.trim().equalsIgnoreCase(INFRA_GENUS_COLUMN.trim())) {
+ normalExplicitRow.setInfraGenus(value);
+ }else if(key.equalsIgnoreCase(SPECIES_COLUMN)) {
+ normalExplicitRow.setSpecies(value);
+ }else if(key.equalsIgnoreCase(INFRA_SPECIES_COLUMN)) {
+ normalExplicitRow.setInfraSpecies(value);
+ } else if (key.equalsIgnoreCase(VERSION_COLUMN)){
+ normalExplicitRow.setVersion(value);
+ }
+
+
+
+
+ else if(key.equalsIgnoreCase("!")) {
//! = Legitimate, * = Illegitimate, ** = Invalid, *** = nom. rej., !! = nom. cons.
if (value.equals("!")){
normalExplicitRow.setNameStatus("accepted");
}
}else {
if (analyzeFeatures(state, keyValue)){
- //ok
+
}else{
String message = "Unexpected column header " + key;
fireWarningEvent(message, state, 10);
state.setUnsuccessfull();
- logger.error(message);
+ //logger.error(message);
}
}
return;
String rankStr = taxonDataHolder.getRank();
String taxonNameStr = taxonDataHolder.getScientificName();
String authorStr = taxonDataHolder.getAuthor();
+ String publishingAuthor= taxonDataHolder.getPublishingAuthor();
+ String basionymAuthor = taxonDataHolder.getBasionymAuthor();
+
String referenceStr = taxonDataHolder.getReference();
String nameStatus = taxonDataHolder.getNameStatus();
String familyNameStr = taxonDataHolder.getFamily();
+ String infraFamilyNameStr = taxonDataHolder.getInfraFamily();
+ String genusNameStr = taxonDataHolder.getGenus();
+ String infraGenusNameStr = taxonDataHolder.getInfraGenus();
+ String speciesNameStr = taxonDataHolder.getSpecies();
+ String infraSpeciesNameStr = taxonDataHolder.getInfraSpecies();
+
+ String version = taxonDataHolder.getVersion();
+
+
+
+
String dateStr = taxonDataHolder.getDate();
- Integer id = taxonDataHolder.getId();
+ String id = taxonDataHolder.getId();
UUID cdmUuid = taxonDataHolder.getCdmUuid();
TaxonBase<?> taxonBase = null;
try {
rank = Rank.getRankByEnglishName(rankStr, state.getConfig().getNomenclaturalCode(), false);
} catch (UnknownCdmTypeException e) {
- //state.setUnsuccessfull();
- logger.error(rankStr + " is not a valid rank.");
+ try {
+ rank = TcsRdfTransformer.rankString2Rank(rankStr);
+ } catch (UnknownCdmTypeException e1) {
+ // TODO Auto-generated catch block
+ e1.printStackTrace();
+ }
+
}
}
//taxon
- taxonBase = createTaxon(state, rank, taxonNameStr, authorStr, referenceStr, dateStr, nameStatus);
+ taxonBase = createTaxon(state, rank, taxonNameStr, authorStr, publishingAuthor, basionymAuthor, referenceStr, dateStr, nameStatus);
}else{
return;
}
}
state.putTaxon(id, taxonBase);
- getTaxonService().save(taxonBase);
-
+ taxonBase = getTaxonService().save(taxonBase);
+ taxonDataHolder.setCdmUuid(taxonBase.getUuid());
return;
}
String taxonNameStr = taxonDataHolder.getScientificName();
String nameStatus = taxonDataHolder.getNameStatus();
String commonNameStr = taxonDataHolder.getCommonName();
- Integer parentId = taxonDataHolder.getParentId();
- Integer childId = taxonDataHolder.getId();
+
+ String synonymNameStr = taxonDataHolder.getSynonym();
+ String basionymNameStr = taxonDataHolder.getBasionym();
+
+ String parentId = taxonDataHolder.getParentId();
+ String childId = taxonDataHolder.getId();
UUID cdmUuid = taxonDataHolder.getCdmUuid();
Taxon acceptedTaxon = null;
TaxonNameBase<?,?> nameUsedInSource = null;
TaxonBase<?> taxonBase = null;
+ Taxon parentTaxon = null;
if (cdmUuid != null){
taxonBase = getTaxonService().find(cdmUuid);
- acceptedTaxon = getAcceptedTaxon(taxonBase);
- nameUsedInSource = taxonBase.getName();
- }else{
- //TODO error handling for class cast
- Taxon parentTaxon = null;
- if (parentId == 0 && state.getParent() == null){
- parentTaxon =(Taxon) getTaxonService().load(((NormalExplicitImportConfigurator)state.getConfig()).getParentUUID());
- state.setParent(parentTaxon);
- }else if (parentId != 0){
- parentTaxon = CdmBase.deproxy(state.getTaxonBase(parentId), Taxon.class);
- } else if (state.getParent() != null){
- parentTaxon = state.getParent();
- }
- if (StringUtils.isNotBlank(taxonNameStr)) {
- taxonBase = state.getTaxonBase(childId);
- if (taxonBase != null){
-
- nameUsedInSource = taxonBase.getName();
- nameStatus = CdmUtils.Nz(nameStatus).trim().toLowerCase();
- if (validMarkers.contains(nameStatus)){
- Taxon taxon = CdmBase.deproxy(taxonBase, Taxon.class);
- acceptedTaxon = taxon;
- // Add the parent relationship
- //if (state.getCurrentRow().getParentId() != 0) {
- MergeResult result = null;
- if (parentTaxon != null) {
- //Taxon taxon = (Taxon)state.getTaxonBase(childId);
-
- Reference sourceRef = state.getConfig().getSourceReference();
- String microCitation = null;
- Taxon childTaxon = taxon;
- makeParent(state, parentTaxon, childTaxon, sourceRef, microCitation);
- getTaxonService().saveOrUpdate(parentTaxon);
- state.putTaxon(parentId, parentTaxon);
- } else {
- String message = "Taxonomic parent not found for " + taxonNameStr;
- logger.warn(message);
- fireWarningEvent(message, state, 6);
- //state.setUnsuccessfull();
- }
-// }else{
-// //do nothing (parent == 0) no parent exists
-// }
- }else if (synonymMarkers.contains(nameStatus)){
- //add synonym relationship
- acceptedTaxon = parentTaxon;
- try {
- Synonym synonym = CdmBase.deproxy(taxonBase,Synonym.class);
- if (acceptedTaxon == null){
- String message = "Accepted/valid taxon could not be found. Please check referential integrity.";
- fireWarningEvent(message, state, 8);
- }else{
- if (parentId != 0){
- //if no relation was defined in file skip relationship creation
- acceptedTaxon.addSynonym(synonym, SynonymType.SYNONYM_OF());
- getTaxonService().saveOrUpdate(acceptedTaxon);
- }
- }
- } catch (Exception e) {
- String message = "Unhandled exception (%s) occurred during synonym import/update";
- message = String.format(message, e.getMessage());
- fireWarningEvent(message, state, 10);
- state.setUnsuccessfull();
- }
- }
- }else{
- acceptedTaxon = null;
- String message = "Unhandled name status (%s)";
- message = String.format(message, nameStatus);
- fireWarningEvent(message, state, 8);
- }
- }else{//taxonNameStr is empty
- //vernacular name case
- acceptedTaxon = parentTaxon;
- nameUsedInSource = null;
+ if (taxonBase != null ){
+ acceptedTaxon = getAcceptedTaxon(taxonBase);
+ nameUsedInSource = taxonBase.getName();
}
+ } else{
+ taxonBase = state.getTaxonBase(childId);
+
+ if (parentId == "0" && state.getParent() == null){
+ parentTaxon =(Taxon) getTaxonService().load(((NormalExplicitImportConfigurator)state.getConfig()).getParentUUID());
+ state.setParent(parentTaxon);
+ }else if (parentId != "0"){
+ parentTaxon = CdmBase.deproxy(state.getTaxonBase(parentId), Taxon.class);
+ } else if (state.getParent() != null){
+ parentTaxon = state.getParent();
+ }
+ if (taxonBase != null ){
+ acceptedTaxon = getAcceptedTaxon(taxonBase);
+ if (synonymNameStr != null){
+ Synonym syn = createSynonym(state,taxonBase,synonymNameStr);
+ acceptedTaxon.addSynonym(syn, SynonymType.HETEROTYPIC_SYNONYM_OF());
+ }
+ if (basionymNameStr != null){
+ Synonym syn = createSynonym(state,taxonBase,basionymNameStr);
+ acceptedTaxon.addSynonym(syn, SynonymType.HOMOTYPIC_SYNONYM_OF());
+ syn.getName().addRelationshipToName(acceptedTaxon.getName(), NameRelationshipType.BASIONYM(), null);
+ }
+ nameUsedInSource = taxonBase.getName();
+
+ //TODO error handling for class cast
+
+
+ nameUsedInSource = taxonBase.getName();
+ nameStatus = CdmUtils.Nz(nameStatus).trim().toLowerCase();
+ if (validMarkers.contains(nameStatus)){
+ Taxon taxon = CdmBase.deproxy(taxonBase, Taxon.class);
+ acceptedTaxon = taxon;
+ // Add the parent relationship
+ //if (state.getCurrentRow().getParentId() != 0) {
+ MergeResult result = null;
+ if (parentTaxon != null) {
+ //Taxon taxon = (Taxon)state.getTaxonBase(childId);
+
+ Reference sourceRef = state.getConfig().getSourceReference();
+ String microCitation = null;
+ Taxon childTaxon = taxon;
+ makeParent(state, parentTaxon, childTaxon, sourceRef, microCitation);
+ getTaxonService().saveOrUpdate(childTaxon);
+ state.putTaxon(parentId, parentTaxon);
+ } else {
+ String message = "Taxonomic parent not found for " + taxonNameStr;
+ logger.warn(message);
+ fireWarningEvent(message, state, 6);
+ //state.setUnsuccessfull();
+ }
+ // }else{
+ // //do nothing (parent == 0) no parent exists
+ // }
+ }else if (synonymMarkers.contains(nameStatus)){
+ //add synonym relationship
+ acceptedTaxon = parentTaxon;
+ try {
+ Synonym synonym = CdmBase.deproxy(taxonBase,Synonym.class);
+ if (acceptedTaxon == null){
+ String message = "Accepted/valid taxon could not be found. Please check referential integrity.";
+ fireWarningEvent(message, state, 8);
+ }else{
+ if (parentId != "0"){
+ //if no relation was defined in file skip relationship creation
+ acceptedTaxon.addSynonym(synonym, SynonymType.SYNONYM_OF());
+ getTaxonService().saveOrUpdate(acceptedTaxon);
+ }
+ }
+ } catch (Exception e) {
+ String message = "Unhandled exception (%s) occurred during synonym import/update";
+ message = String.format(message, e.getMessage());
+ fireWarningEvent(message, state, 10);
+ state.setUnsuccessfull();
+ }
+
+ }else{
+ if (parentTaxon != null) {
+ Taxon taxon = (Taxon)state.getTaxonBase(childId);
+
+ Reference sourceRef = state.getConfig().getSourceReference();
+ String microCitation = null;
+ Taxon childTaxon = taxon;
+ makeParent(state, parentTaxon, childTaxon, sourceRef, microCitation);
+ getTaxonService().saveOrUpdate(parentTaxon);
+ state.putTaxon(parentId, parentTaxon);
+ } else {
+ String message = "Taxonomic parent not found for " + taxonNameStr;
+ logger.warn(message);
+ fireWarningEvent(message, state, 6);
+ //state.setUnsuccessfull();
+ }
+ }
+
+
+ }
+ if (StringUtils.isBlank(taxonNameStr) && acceptedTaxon == null) {
+ acceptedTaxon = parentTaxon;
+ nameUsedInSource = null;
+ }
}
-
if (acceptedTaxon == null && (StringUtils.isNotBlank(commonNameStr) ||taxonDataHolder.getFeatures().size() > 0 )){
String message = "Accepted taxon could not be found. Can't add additional data (common names, descriptive data, ...) to taxon";
fireWarningEvent(message, state, 6);
/**
+ * @param state
+ * @param taxonBase
+ * @param synonymNameStr
+ */
+ private Synonym createSynonym(TaxonExcelImportState state, TaxonBase<?> taxonBase, String synonymNameStr) {
+ NomenclaturalCode nc = state.getConfig().getNomenclaturalCode();
+ TaxonNameBase name = null;
+ if (nc.isKindOf(NomenclaturalCode.ICZN)){
+ name = ZoologicalName.NewInstance(taxonBase.getName().getRank());
+ }else if (nc.isKindOf(NomenclaturalCode.ICNAFP)){
+ name = BotanicalName.NewInstance(taxonBase.getName().getRank());
+ } else{
+ name = NonViralName.NewInstance(taxonBase.getName().getRank());
+ }
+ name.setTitleCache(synonymNameStr, true);
+ if (name != null){
+ return Synonym.NewInstance(name, null);
+ }
+ logger.debug("The nomenclatural code is not supported.");
+ return null;
+ }
+
+
+ /**
* @param state
* @param taxonDataHolder
* @param acceptedTaxon
* @return
*/
private TaxonBase createTaxon(TaxonExcelImportState state, Rank rank,
- String taxonNameStr, String authorStr, String reference, String date, String nameStatus) {
+ String familyNameStr, String infraFamilyNameStr, String genusNameStr, String infraGenusNameStr, String speciesNameStr, String infraSpeciesNameStr, String authorStr, String publishingAuthorStr, String basionymAuthorStr,String reference, String date, String nameStatus) {
// Create the taxon name object depending on the setting of the nomenclatural code
// in the configurator (botanical code, zoological code, etc.)
- if (StringUtils.isBlank(taxonNameStr)){
- return null;
- }
+
NomenclaturalCode nc = getConfigurator().getNomenclaturalCode();
TaxonBase taxonBase;
-
- String titleCache = CdmUtils.concat(" ", taxonNameStr, authorStr);
+ String nameCache = null;
+ if (rank == null){
+ System.err.println("bla");
+ }
+ if (rank.isGenus()){
+ nameCache =genusNameStr;
+ } else if (rank.isInfraGeneric()){
+ nameCache =CdmUtils.concat(" " +rank.getIdInVocabulary() + " ",genusNameStr,infraGenusNameStr);
+
+ } else if (rank.isSpecies()){
+ nameCache = CdmUtils.concat(" ", genusNameStr,speciesNameStr);
+ } else if (rank.isInfraSpecific()){
+ nameCache = CdmUtils.concat(" " +rank.getIdInVocabulary() + " ",genusNameStr,infraGenusNameStr);
+ }
if (! synonymMarkers.contains(nameStatus) && state.getConfig().isReuseExistingTaxaWhenPossible()){
- titleCache = CdmUtils.concat(" ", taxonNameStr, authorStr);
- taxonBase = getTaxonService().findBestMatchingTaxon(titleCache);
+ taxonBase = getTaxonService().findBestMatchingTaxon(nameCache);
}else{
- taxonBase = getTaxonService().findBestMatchingSynonym(titleCache);
+ taxonBase = getTaxonService().findBestMatchingSynonym(nameCache);
if (taxonBase != null){
- logger.info("Matching taxon/synonym found for " + titleCache);
+ logger.info("Matching taxon/synonym found for " + nameCache);
}
}
if (taxonBase != null){
- logger.info("Matching taxon/synonym found for " + titleCache);
+ logger.info("Matching taxon/synonym found for " + nameCache);
return null;
}else {
- taxonBase = createTaxon(state, rank, taxonNameStr, authorStr, reference, date, nameStatus, nc);
+ taxonBase = createTaxon(state, rank, nameCache, authorStr, publishingAuthorStr, basionymAuthorStr, reference, date, nameStatus, nc);
}
return taxonBase;
}
+ /**
+ * @param state
+ * @param rank
+ * @param taxonNameStr
+ * @param authorStr
+ * @param nameStatus
+ * @param nameStatus2
+ * @return
+ */
+ private TaxonBase createTaxon(TaxonExcelImportState state, Rank rank,
+ String taxonNameStr, String authorStr, String publishingAuthorStr, String basionymAuthorStr,String reference, String date, String nameStatus) {
+ // Create the taxon name object depending on the setting of the nomenclatural code
+ // in the configurator (botanical code, zoological code, etc.)
+ if (StringUtils.isBlank(taxonNameStr)){
+ return null;
+ }
+ NomenclaturalCode nc = getConfigurator().getNomenclaturalCode();
+
+ TaxonBase taxonBase = null;
+
+ String titleCache = CdmUtils.concat(" ", taxonNameStr, authorStr);
+ if (! synonymMarkers.contains(nameStatus) && state.getConfig().isReuseExistingTaxaWhenPossible()){
+ titleCache = CdmUtils.concat(" ", taxonNameStr, authorStr);
+ taxonBase = getTaxonService().findBestMatchingTaxon(titleCache);
+ }else if ( state.getConfig().isReuseExistingTaxaWhenPossible()){
+ taxonBase = getTaxonService().findBestMatchingSynonym(titleCache);
+ if (taxonBase != null){
+ logger.info("Matching taxon/synonym found for " + titleCache);
+ }
+ }
+ if (taxonBase != null){
+ logger.info("Matching taxon/synonym found for " + titleCache);
+ return null;
+ }else {
+ taxonBase = createTaxon(state, rank, taxonNameStr, authorStr, publishingAuthorStr, basionymAuthorStr, reference, date, nameStatus, nc);
+ }
+ return taxonBase;
+ }
* @return
*/
private TaxonBase<?> createTaxon(TaxonExcelImportState state, Rank rank, String taxonNameStr,
- String authorStr, String reference, String date, String nameStatus, NomenclaturalCode nc) {
+ String authorStr, String publishingAutorStr, String basionymAuthor, String reference, String date, String nameStatus, NomenclaturalCode nc) {
TaxonBase<?> taxonBase;
NonViralName<?> taxonNameBase = null;
if (nc == NomenclaturalCode.ICVCN){
logger.warn("ICVCN not yet supported");
}else{
+ //String taxonNameStr = titleCache.substring(0, titleCache.indexOf(authorStr));
taxonNameBase =(NonViralName<?>) nc.getNewTaxonNameInstance(rank);
//NonViralName nonViralName = (NonViralName)taxonNameBase;
NonViralNameParserImpl parser = NonViralNameParserImpl.NewInstance();
ref.setProtectedTitleCache(false);
taxonNameBase.setNomenclaturalReference(ref);
+ taxonNameBase.setNomenclaturalMicroReference(state.getCurrentRow().getCollation());
}
}
}
taxonBase = taxon;
}
+ taxonBase.getName().addSource(OriginalSourceType.Import, "urn:lsid:ipni.org:names:"+ state.getCurrentRow().getId()+":"+state.getCurrentRow().getVersion(),"TaxonName" ,null, null);
+ taxonBase.addSource(OriginalSourceType.Import, "urn:lsid:ipni.org:names:"+ state.getCurrentRow().getId()+":"+state.getCurrentRow().getVersion(),"TaxonName" ,null, null);
+
return taxonBase;
}
*/\r
public class NormalExplicitRow extends ExcelRowBase {\r
\r
- private int id;\r
- private int parentId;\r
- private String rank;\r
- private String scientificName;\r
- private String author;\r
- private String nameStatus;\r
- private String commonName;\r
- private String language;\r
- private String reference;\r
- private String date;\r
- private String family;\r
+
+ private String id;\r
+ private String parentId;\r
+ private String rank;\r
+ private String scientificName;\r
+ private String author;\r
+ private String basionymAuthor;\r
+ private String publishingAuthor;\r
+ private String nameStatus;\r
+ private String commonName;\r
+ private String language;\r
+ private String reference;\r
+ private String date;\r
+ private String family;\r
+ private String infraFamily;\r
+ private String genus;\r
+ private String infraGenus;\r
+ private String species;\r
+ private String infraSpecies;\r
+\r
+ private String collation;\r
+ private String publicationYear;\r
+ private String remarks;\r
+\r
+ private String synonym;\r
+ private String basionym;\r
+\r
+ private String version;\r
+
\r
//Sets\r
private TreeMap<Integer, String> distributions = new TreeMap<Integer, String>();\r
private TreeMap<Integer, String> images = new TreeMap<Integer, String>();\r
\r
public NormalExplicitRow() {\r
- this.id = 0;\r
- this.parentId = 0;\r
+
+ this.id = "0";\r
+ this.parentId = "0";\r
+
this.rank = "";\r
this.scientificName = "";\r
this.author = "";\r
this.setFamily("");\r
}\r
\r
- public NormalExplicitRow(String name, int parentId) {\r
+ public NormalExplicitRow(String name, String parentId) {\r
this(name, parentId, null);\r
}\r
\r
- public NormalExplicitRow(String scientificName, int parentId, String reference) {\r
+ public NormalExplicitRow(String scientificName, String parentId, String reference) {\r
this.parentId = parentId;\r
this.scientificName = scientificName;\r
this.reference = reference;\r
/**\r
* @return the parentId\r
*/\r
- public int getParentId() {\r
+ public String getParentId() {\r
return parentId;\r
}\r
/**\r
* @param parentId the parentId to set\r
*/\r
- public void setParentId(int parentId) {\r
+ public void setParentId(String parentId) {\r
this.parentId = parentId;\r
}\r
/**\r
/**\r
* @return the id\r
*/\r
- public int getId() {\r
+ public String getId() {\r
return id;\r
}\r
\r
/**\r
* @param id the id to set\r
*/\r
- public void setId(int id) {\r
+ public void setId(String id) {\r
this.id = id;\r
}\r
\r
this.family = family;\r
}\r
\r
+ /**\r
+ * @return the basionymAuthor\r
+ */\r
+ public String getBasionymAuthor() {\r
+ return basionymAuthor;\r
+ }\r
+\r
+ /**\r
+ * @param basionymAuthor the basionymAuthor to set\r
+ */\r
+ public void setBasionymAuthor(String basionymAuthor) {\r
+ this.basionymAuthor = basionymAuthor;\r
+ }\r
+\r
+ /**\r
+ * @return the infraFamily\r
+ */\r
+ public String getInfraFamily() {\r
+ return infraFamily;\r
+ }\r
+\r
+ /**\r
+ * @param infraFamily the infraFamily to set\r
+ */\r
+ public void setInfraFamily(String infraFamily) {\r
+ this.infraFamily = infraFamily;\r
+ }\r
+\r
+ /**\r
+ * @return the genus\r
+ */\r
+ public String getGenus() {\r
+ return genus;\r
+ }\r
+\r
+ /**\r
+ * @param genus the genus to set\r
+ */\r
+ public void setGenus(String genus) {\r
+ this.genus = genus;\r
+ }\r
+\r
+ /**\r
+ * @return the infraGenus\r
+ */\r
+ public String getInfraGenus() {\r
+ return infraGenus;\r
+ }\r
+\r
+ /**\r
+ * @param infraGenus the infraGenus to set\r
+ */\r
+ public void setInfraGenus(String infraGenus) {\r
+ this.infraGenus = infraGenus;\r
+ }\r
+\r
+ /**\r
+ * @return the species\r
+ */\r
+ public String getSpecies() {\r
+ return species;\r
+ }\r
+\r
+ /**\r
+ * @param species the species to set\r
+ */\r
+ public void setSpecies(String species) {\r
+ this.species = species;\r
+ }\r
+\r
+ /**\r
+ * @return the infraSpecies\r
+ */\r
+ public String getInfraSpecies() {\r
+ return infraSpecies;\r
+ }\r
+\r
+ /**\r
+ * @param infraSpecies the infraSpecies to set\r
+ */\r
+ public void setInfraSpecies(String infraSpecies) {\r
+ this.infraSpecies = infraSpecies;\r
+ }\r
+\r
+ /**\r
+ * @return the collation\r
+ */\r
+ public String getCollation() {\r
+ return collation;\r
+ }\r
+\r
+ /**\r
+ * @param collation the collation to set\r
+ */\r
+ public void setCollation(String collation) {\r
+ this.collation = collation;\r
+ }\r
+\r
+ /**\r
+ * @return the publicationYear\r
+ */\r
+ public String getPublicationYear() {\r
+ return publicationYear;\r
+ }\r
+\r
+ /**\r
+ * @param publicationYear the publicationYear to set\r
+ */\r
+ public void setPublicationYear(String publicationYear) {\r
+ this.publicationYear = publicationYear;\r
+ }\r
+\r
+ /**\r
+ * @return the remarks\r
+ */\r
+ public String getRemarks() {\r
+ return remarks;\r
+ }\r
+\r
+ /**\r
+ * @param remarks the remarks to set\r
+ */\r
+ public void setRemarks(String remarks) {\r
+ this.remarks = remarks;\r
+ }\r
+\r
+ /**\r
+ * @return the synonym\r
+ */\r
+ public String getSynonym() {\r
+ return synonym;\r
+ }\r
+\r
+ /**\r
+ * @param synonym the synonym to set\r
+ */\r
+ public void setSynonym(String synonym) {\r
+ this.synonym = synonym;\r
+ }\r
+\r
+ /**\r
+ * @return the basionym\r
+ */\r
+ public String getBasionym() {\r
+ return basionym;\r
+ }\r
+\r
+ /**\r
+ * @param basionym the basionym to set\r
+ */\r
+ public void setBasionym(String basionym) {\r
+ this.basionym = basionym;\r
+ }\r
+\r
+ /**\r
+ * @return the publishingAuthor\r
+ */\r
+ public String getPublishingAuthor() {\r
+ return publishingAuthor;\r
+ }\r
+\r
+ /**\r
+ * @param publishingAuthor the publishingAuthor to set\r
+ */\r
+ public void setPublishingAuthor(String publishingAuthor) {\r
+ this.publishingAuthor = publishingAuthor;\r
+ }\r
+\r
+ /**\r
+ * @return the version\r
+ */\r
+ public String getVersion() {\r
+ return version;\r
+ }\r
+\r
+ /**\r
+ * @param version the version to set\r
+ */\r
+ public void setVersion(String version) {\r
+ this.version = version;\r
+ }\r
+
\r
\r
\r
BGBM BDI Projects / cdmlib.git / commitdiff