-/**\r
- * Copyright (C) 2007 EDIT\r
- * European Distributed Institute of Taxonomy \r
- * http://www.e-taxonomy.eu\r
- * \r
- * The contents of this file are subject to the Mozilla Public License Version 1.1\r
- * See LICENSE.TXT at the top of this package for the full license terms.\r
- */\r
-\r
-package eu.etaxonomy.cdm.io.cyprus;\r
-\r
-import java.util.Arrays;\r
-import java.util.HashMap;\r
-import java.util.HashSet;\r
-import java.util.List;\r
-import java.util.Set;\r
-import java.util.UUID;\r
-\r
-import org.apache.commons.lang.StringUtils;\r
-import org.apache.log4j.Logger;\r
-import org.springframework.stereotype.Component;\r
-\r
-import eu.etaxonomy.cdm.common.CdmUtils;\r
-import eu.etaxonomy.cdm.io.common.mapping.IInputTransformer;\r
-import eu.etaxonomy.cdm.io.common.mapping.UndefinedTransformerMethodException;\r
-import eu.etaxonomy.cdm.io.excel.common.ExcelImporterBase;\r
-import eu.etaxonomy.cdm.model.common.Language;\r
-import eu.etaxonomy.cdm.model.description.Distribution;\r
-import eu.etaxonomy.cdm.model.description.Feature;\r
-import eu.etaxonomy.cdm.model.description.PresenceTerm;\r
-import eu.etaxonomy.cdm.model.description.TaxonDescription;\r
-import eu.etaxonomy.cdm.model.description.TextData;\r
-import eu.etaxonomy.cdm.model.location.NamedArea;\r
-import eu.etaxonomy.cdm.model.location.TdwgArea;\r
-import eu.etaxonomy.cdm.model.name.BotanicalName;\r
-import eu.etaxonomy.cdm.model.name.NomenclaturalCode;\r
-import eu.etaxonomy.cdm.model.name.NonViralName;\r
-import eu.etaxonomy.cdm.model.name.Rank;\r
-import eu.etaxonomy.cdm.model.reference.Reference;\r
-import eu.etaxonomy.cdm.model.taxon.Classification;\r
-import eu.etaxonomy.cdm.model.taxon.Synonym;\r
-import eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType;\r
-import eu.etaxonomy.cdm.model.taxon.Taxon;\r
-import eu.etaxonomy.cdm.model.taxon.TaxonBase;\r
-import eu.etaxonomy.cdm.strategy.parser.INonViralNameParser;\r
-import eu.etaxonomy.cdm.strategy.parser.NonViralNameParserImpl;\r
-\r
-/**\r
- * @author a.babadshanjan\r
- * @created 08.01.2009\r
- * @version 1.0\r
- */\r
-\r
-@Component\r
-public class CyprusExcelImport extends ExcelImporterBase<CyprusImportState> {\r
- private static final Logger logger = Logger.getLogger(CyprusExcelImport.class);\r
- \r
- public static Set<String> validMarkers = new HashSet<String>(Arrays.asList(new String[]{"", "valid", "accepted", "a", "v", "t"}));\r
- public static Set<String> synonymMarkers = new HashSet<String>(Arrays.asList(new String[]{"", "invalid", "synonym", "s", "i"}));\r
- \r
- \r
- @Override\r
- protected boolean isIgnore(CyprusImportState state) {\r
- return ! state.getConfig().isDoTaxa();\r
- }\r
- \r
- \r
- /* (non-Javadoc)\r
- * @see eu.etaxonomy.cdm.io.common.CdmIoBase#doCheck(eu.etaxonomy.cdm.io.common.IoStateBase)\r
- */\r
- @Override\r
- protected boolean doCheck(CyprusImportState state) {\r
- logger.warn("DoCheck not yet implemented for CyprusExcelImport");\r
- return true;\r
- }\r
-\r
-// protected static final String ID_COLUMN = "Id";\r
- protected static final String SPECIES_COLUMN = "species";\r
- protected static final String SUBSPECIES_COLUMN = "subspecies";\r
- protected static final String GENUS_COLUMN = "genus";\r
- protected static final String FAMILY_COLUMN = "family";\r
- protected static final String DIVISION_COLUMN = "division";\r
- protected static final String HOMOTYPIC_SYNONYM_COLUMN = "homotypic synonyms";\r
- protected static final String HETEROTYPIC_SYNONYMS_COLUMN = "heterotypic synonyms";\r
- protected static final String ENDEMISM_COLUMN = "endemism";\r
-\r
- protected static final String STATUS_COLUMN = "status";\r
- protected static final String RED_DATA_BOOK_CATEGORY_COLUMN = "red data book category";\r
- protected static final String SYSTEMATICS_COLUMN = "systematics";\r
- \r
- \r
- \r
- // TODO: This enum is for future use (perhaps).\r
- protected enum Columns { \r
-// Id("Id"), \r
- Species("species"), \r
- Subspecies("subspecies"),\r
- Genus("genus"),\r
- Family("family"),\r
- Division("division"),\r
- HomotypicSynonyms("homotypic synonyms"),\r
- HeterotypicSynonyms("heterotypic synonyms"),\r
- Status("status"),\r
- Endemism("endemism");\r
- \r
- private String head;\r
- private String value;\r
- \r
- private Columns(String head) {\r
- this.head = head;\r
- }\r
- \r
- public String head() {\r
- return this.head;\r
- }\r
- \r
- public String value() {\r
- return this.value;\r
- }\r
- }\r
- \r
- \r
- @Override\r
- protected void analyzeRecord(HashMap<String, String> record, CyprusImportState state) {\r
- \r
- Set<String> keys = record.keySet();\r
- \r
- CyprusRow cyprusRow = new CyprusRow();\r
- state.setCyprusRow(cyprusRow);\r
- \r
- for (String originalKey: keys) {\r
- Integer index = 0;\r
- String indexedKey = CdmUtils.removeDuplicateWhitespace(originalKey.trim()).toString();\r
- String[] split = indexedKey.split("_");\r
- String key = split[0];\r
- if (split.length > 1){\r
- String indexString = split[1];\r
- try {\r
- index = Integer.valueOf(indexString);\r
- } catch (NumberFormatException e) {\r
- String message = "Index must be integer";\r
- logger.error(message);\r
- continue;\r
- }\r
- }\r
- \r
- String value = (String) record.get(indexedKey);\r
- if (! StringUtils.isBlank(value)) {\r
- if (logger.isDebugEnabled()) { logger.debug(key + ": " + value); }\r
- value = CdmUtils.removeDuplicateWhitespace(value.trim()).toString();\r
- }else{\r
- continue;\r
- }\r
- \r
- \r
- if (key.equalsIgnoreCase(SPECIES_COLUMN)) {\r
-// int ivalue = floatString2IntValue(value);\r
- cyprusRow.setSpecies(value);\r
- \r
- } else if(key.equalsIgnoreCase(SUBSPECIES_COLUMN)) {\r
- cyprusRow.setSubspecies(value);\r
- \r
- } else if(key.equalsIgnoreCase(HOMOTYPIC_SYNONYM_COLUMN)) {\r
- cyprusRow.setHomotypicSynonyms(value);\r
- \r
- } else if(key.equalsIgnoreCase(HETEROTYPIC_SYNONYMS_COLUMN)) {\r
- cyprusRow.setHeterotypicSynonyms(value);\r
- \r
- } else if(key.equalsIgnoreCase(ENDEMISM_COLUMN)) {\r
- cyprusRow.setEndemism(value);\r
- \r
- } else if(key.equalsIgnoreCase(STATUS_COLUMN)) {\r
- cyprusRow.setStatus(value);\r
- \r
- } else if(key.equalsIgnoreCase(RED_DATA_BOOK_CATEGORY_COLUMN)) {\r
- cyprusRow.setRedDataBookCategory(value);\r
- \r
- } else if(key.equalsIgnoreCase(SYSTEMATICS_COLUMN)) {\r
- cyprusRow.setSystematics(value);\r
- \r
- } else if(key.equalsIgnoreCase(GENUS_COLUMN)) {\r
- cyprusRow.setGenus(value);\r
- \r
- } else if(key.equalsIgnoreCase(FAMILY_COLUMN)) {\r
- cyprusRow.setFamily(value);\r
- \r
- } else if(key.equalsIgnoreCase(DIVISION_COLUMN)) {\r
- cyprusRow.setDivision(value);\r
- \r
- } else {\r
- state.setUnsuccessfull();\r
- logger.error("Unexpected column header " + key);\r
- }\r
- }\r
- return;\r
- }\r
- \r
- private static INonViralNameParser nameParser = NonViralNameParserImpl.NewInstance();\r
- private static NomenclaturalCode nc = NomenclaturalCode.ICBN;\r
- private Feature redBookCategory;\r
- private Feature endemism;\r
- private PresenceTerm indigenous;\r
- private PresenceTerm indigenousDoubtful;\r
- private PresenceTerm cultivatedDoubtful;\r
- \r
- private PresenceTerm casual;\r
- private PresenceTerm casualDoubtful;\r
- private PresenceTerm nonInvasive;\r
- private PresenceTerm nonInvasiveDoubtful;\r
- private PresenceTerm invasive;\r
- private PresenceTerm invasiveDoubtful;\r
- private PresenceTerm questionable;\r
- private PresenceTerm questionableDoubtful;\r
- \r
- private boolean termsCreated = false;\r
- \r
- private boolean makeTerms(CyprusImportState state) {\r
- if (termsCreated == false){\r
- IInputTransformer transformer = state.getTransformer();\r
- \r
- try {\r
- //feature\r
- UUID redBookUuid = transformer.getFeatureUuid("Red book");\r
- redBookCategory = this.getFeature(state, redBookUuid, "Red book category", "Red data book category", "Red book");\r
- getTermService().save(redBookCategory);\r
- \r
- UUID endemismUuid = transformer.getFeatureUuid("Endemism");\r
- endemism = this.getFeature(state, endemismUuid, "Endemism", "Endemism", "Endemism");\r
- getTermService().save(endemism);\r
- \r
- //status\r
- \r
- UUID indigenousUuid = transformer.getPresenceTermUuid("IN");\r
- indigenous = this.getPresenceTerm(state, indigenousUuid, "indigenous", "Indigenous", "IN");\r
- getTermService().save(indigenous);\r
- UUID indigenousDoubtfulUuid = transformer.getPresenceTermUuid("IN?");\r
- indigenousDoubtful = this.getPresenceTerm(state, indigenousDoubtfulUuid, "indigenous?", "Indigenous?", "IN?");\r
- getTermService().save(indigenousDoubtful);\r
-\r
- UUID cultivatedDoubtfulUuid = transformer.getPresenceTermUuid("CU?");\r
- cultivatedDoubtful = this.getPresenceTerm(state, cultivatedDoubtfulUuid, "cultivated?", "Cultivated?", "CU?");\r
- getTermService().save(cultivatedDoubtful);\r
- \r
- \r
- UUID casualUuid = transformer.getPresenceTermUuid("CA");\r
- casual = this.getPresenceTerm(state, casualUuid, "casual", "Casual", "CA");\r
- getTermService().save(casual);\r
- UUID casualDoubtfulUuid = transformer.getPresenceTermUuid("CA?");\r
- casualDoubtful = this.getPresenceTerm(state, casualDoubtfulUuid, "casual?", "Casual?", "CA?");\r
- getTermService().save(casualDoubtful);\r
-\r
- \r
- UUID nonInvasiveUuid = transformer.getPresenceTermUuid("NN");\r
- nonInvasive = this.getPresenceTerm(state, nonInvasiveUuid, "naturalized non-invasive", "Naturalized non-invasive", "NN");\r
- getTermService().save(nonInvasive);\r
- UUID nonInvasiveDoubtfulUuid = transformer.getPresenceTermUuid("NN?");\r
- nonInvasiveDoubtful = this.getPresenceTerm(state, nonInvasiveDoubtfulUuid, "naturalized non-invasive?", "Naturalized non-invasive?", "NN?");\r
- getTermService().save(nonInvasiveDoubtful);\r
- \r
- UUID invasiveUuid = transformer.getPresenceTermUuid("NA");\r
- invasive = this.getPresenceTerm(state, invasiveUuid, "naturalized invasive", "Naturalized invasive", "NA");\r
- getTermService().save(invasive);\r
- UUID invasiveDoubtfulUuid = transformer.getPresenceTermUuid("NA?");\r
- invasiveDoubtful = this.getPresenceTerm(state, invasiveDoubtfulUuid, "naturalized invasive?", "Naturalized invasive?", "NA?");\r
- getTermService().save(invasiveDoubtful);\r
- \r
- UUID questionableUuid = transformer.getPresenceTermUuid("Q");\r
- questionable = this.getPresenceTerm(state, questionableUuid, "questionable", "Questionable", "Q");\r
- getTermService().save(questionable);\r
- UUID questionableDoubtfulUuid = transformer.getPresenceTermUuid("Q?");\r
- questionableDoubtful = this.getPresenceTerm(state, questionableDoubtfulUuid, "questionable?", "Questionable?", "Q?");\r
- getTermService().save(questionableDoubtful);\r
- \r
- termsCreated = true;\r
- \r
- return true;\r
- } catch (UndefinedTransformerMethodException e) {\r
- e.printStackTrace();\r
- return false;\r
- }\r
- }\r
- return true;\r
- \r
- }\r
- \r
- /** \r
- * Stores taxa records in DB\r
- */\r
- @Override\r
- protected void firstPass(CyprusImportState state) {\r
- \r
- makeTerms(state);\r
- CyprusRow taxonLight = state.getCyprusRow();\r
- Reference citation = null;\r
- String microCitation = null;\r
- \r
- //species name\r
- String speciesStr = taxonLight.getSpecies();\r
- String subSpeciesStr = taxonLight.getSubspecies();\r
- String homotypicSynonymsString = taxonLight.getHomotypicSynonyms();\r
- List<String> homotypicSynonymList = Arrays.asList(homotypicSynonymsString.split(";"));\r
- String heterotypicSynonymsString = taxonLight.getHeterotypicSynonyms();\r
- List<String> heterotypicSynonymList = Arrays.asList(heterotypicSynonymsString.split(";"));\r
- \r
- String systematicsString = taxonLight.getSystematics();\r
- String endemismString = taxonLight.getEndemism();\r
- String statusString = taxonLight.getStatus();\r
- String redBookCategory = taxonLight.getRedDataBookCategory();\r
- \r
- if (StringUtils.isNotBlank(speciesStr)) {\r
- boolean speciesIsExisting = false;\r
- Taxon mainTaxon = null;\r
- //species\r
- Taxon speciesTaxon = (Taxon)createTaxon(state, Rank.SPECIES(), speciesStr, Taxon.class, nc);\r
- mainTaxon = speciesTaxon;\r
- \r
- //subspecies\r
- if (StringUtils.isNotBlank(subSpeciesStr)){\r
- Taxon existingSpecies = state.getHigherTaxon(speciesStr);\r
- if (existingSpecies != null){\r
- speciesIsExisting = true;\r
- speciesTaxon = existingSpecies;\r
- }\r
- \r
- Taxon subSpeciesTaxon = (Taxon)createTaxon(state, Rank.SUBSPECIES(), subSpeciesStr, Taxon.class, nc);\r
- \r
- if (subSpeciesTaxon != null){\r
- makeParent(state, speciesTaxon, subSpeciesTaxon, citation, microCitation);\r
- }\r
- mainTaxon = subSpeciesTaxon;\r
- state.putHigherTaxon(speciesStr, speciesTaxon);\r
- }\r
- \r
- if (! speciesIsExisting){\r
- makeHigherTaxa(state, taxonLight, speciesTaxon, citation, microCitation);\r
- }\r
- makeHomotypicSynonyms(state, citation, microCitation, homotypicSynonymList, mainTaxon); \r
- makeHeterotypicSynonyms(state, citation, microCitation, heterotypicSynonymList, mainTaxon); \r
- makeSystematics(systematicsString, mainTaxon);\r
- makeEndemism(endemismString, mainTaxon);\r
- makeStatus(statusString, mainTaxon);\r
- makeRedBookCategory(redBookCategory, mainTaxon);\r
- \r
-// state.putHigherTaxon(higherName, uuid);//(speciesStr, mainTaxon);\r
- getTaxonService().save(mainTaxon);\r
- }\r
- return;\r
- }\r
-\r
-\r
- private void makeHigherTaxa(CyprusImportState state, CyprusRow taxonLight, Taxon speciesTaxon, Reference citation, String microCitation) {\r
- String divisionStr = taxonLight.getDivision();\r
- String genusStr = taxonLight.getGenus();\r
- String familyStr = taxonLight.getFamily();\r
- \r
- Taxon division = getTaxon(state, divisionStr, Rank.DIVISION(), null, citation, microCitation);\r
- Taxon family = getTaxon(state, familyStr, Rank.FAMILY(), division, citation, microCitation);\r
- Taxon genus = getTaxon(state, genusStr, Rank.GENUS(), family, citation, microCitation);\r
- makeParent(state, genus, speciesTaxon, citation, microCitation) ;\r
- }\r
-\r
-\r
- private Taxon getTaxon(CyprusImportState state, String taxonNameStr, Rank rank, Taxon parent, Reference citation, String microCitation) {\r
- Taxon result;\r
- if (state.containsHigherTaxon(taxonNameStr)){\r
- result = state.getHigherTaxon(taxonNameStr);\r
- }else{\r
- result = (Taxon)createTaxon(state, rank, taxonNameStr, Taxon.class, nc);\r
- state.putHigherTaxon(taxonNameStr, result);\r
- if (parent == null){\r
- makeParent(state, null,result, citation, microCitation);\r
- }else{\r
- makeParent(state, parent, result, citation, microCitation);\r
- }\r
- \r
- }\r
- return result;\r
- }\r
-\r
-\r
- private void makeHomotypicSynonyms(CyprusImportState state,\r
- Reference citation, String microCitation, List<String> homotypicSynonymList, Taxon mainTaxon) {\r
- for (String homotypicSynonym: homotypicSynonymList){\r
- if (StringUtils.isNotBlank(homotypicSynonym)){\r
- Synonym synonym = (Synonym)createTaxon(state, null, homotypicSynonym, Synonym.class, nc);\r
- mainTaxon.addHomotypicSynonym(synonym, citation, microCitation);\r
- }\r
- }\r
- }\r
-\r
-\r
- private void makeHeterotypicSynonyms(CyprusImportState state, Reference citation, String microCitation, List<String> heterotypicSynonymList, Taxon mainTaxon) {\r
- for (String heterotypicSynonym: heterotypicSynonymList){\r
- if (StringUtils.isNotBlank(heterotypicSynonym)){\r
- Synonym synonym = (Synonym)createTaxon(state, null, heterotypicSynonym, Synonym.class, nc);\r
- mainTaxon.addSynonym(synonym, SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF(), citation, microCitation);\r
- }\r
- }\r
- }\r
-\r
-\r
- private void makeSystematics(String systematicsString, Taxon mainTaxon) {\r
- //Systematics\r
- if (StringUtils.isNotBlank(systematicsString)){\r
- TaxonDescription td = this.getTaxonDescription(mainTaxon, false, true);\r
- TextData textData = TextData.NewInstance(Feature.SYSTEMATICS());\r
- textData.putText(Language.UNDETERMINED(), systematicsString);\r
- td.addElement(textData);\r
- }\r
- }\r
-\r
-\r
- private void makeEndemism(String endemismString, Taxon mainTaxon) {\r
- //endemism\r
- if (StringUtils.isNotBlank(endemismString)){\r
- //OLD - not wanted as marker\r
-// boolean flag;\r
-// if (endemismString.trim().equalsIgnoreCase("not endemic") || endemismString.trim().equalsIgnoreCase("ne?")){\r
-// flag = false;\r
-// }else if (endemismString.trim().equalsIgnoreCase("endemic")){\r
-// flag = true;\r
-// }else{\r
-// throw new RuntimeException(endemismString + " is not a valid value for endemism");\r
-// }\r
-// Marker marker = Marker.NewInstance(MarkerType.ENDEMIC(), flag);\r
-// mainTaxon.addMarker(marker);\r
- //text data\r
- TaxonDescription td = this.getTaxonDescription(mainTaxon, false, true);\r
- TextData textData = TextData.NewInstance(endemism);\r
- textData.putText(Language.ENGLISH(), endemismString);\r
- td.addElement(textData);\r
- }\r
- }\r
-\r
-\r
- private void makeStatus(String statusString, Taxon mainTaxon) {\r
- //status\r
- if (StringUtils.isNotBlank(statusString)){\r
- PresenceTerm status = null;\r
- if (statusString.contains("Indigenous?")){\r
- status = indigenousDoubtful;\r
- }else if (statusString.contains("Indigenous")){\r
- status = indigenous;\r
- }else if (statusString.contains("Casual?") || statusString.contains("Causal?")){\r
- status = casualDoubtful;\r
- }else if (statusString.contains("Casual")){\r
- status = casual;\r
- }else if (statusString.contains("Cultivated?")){\r
- status = cultivatedDoubtful;\r
- }else if (statusString.contains("Cultivated")){\r
- status = PresenceTerm.CULTIVATED();\r
- }else if (statusString.contains("non-invasive?")){\r
- status = nonInvasiveDoubtful;\r
- }else if (statusString.contains("non-invasive")){\r
- status = nonInvasive;\r
- }else if (statusString.contains("invasive?")){\r
- status = invasiveDoubtful;\r
- }else if (statusString.contains("invasive")){\r
- status = invasive;\r
- }else if (statusString.contains("Questionable?")){\r
- status = questionableDoubtful;\r
- }else if (statusString.contains("Questionable")){\r
- status = questionable;\r
- }else if (statusString.startsWith("F")){\r
- status = null;\r
- }else if (statusString.equals("##")){\r
- status = null;\r
- }else{\r
- logger.warn("Unknown status: " + statusString);\r
- status = null;\r
- }\r
- TaxonDescription td = this.getTaxonDescription(mainTaxon, false, true);\r
- NamedArea area = TdwgArea.getAreaByTdwgAbbreviation("CYP");\r
- Distribution distribution = Distribution.NewInstance(area, status);\r
- td.addElement(distribution);\r
- \r
- //text data\r
- TextData textData = TextData.NewInstance(Feature.STATUS());\r
- textData.putText(Language.ENGLISH(), statusString);\r
- td.addElement(textData);\r
- }\r
- }\r
-\r
-\r
- private void makeRedBookCategory(String redBookCategory, Taxon mainTaxon) {\r
- //red data book category\r
- if (StringUtils.isNotBlank(redBookCategory)){\r
- TaxonDescription td = this.getTaxonDescription(mainTaxon, false, true);\r
- TextData textData = TextData.NewInstance(this.redBookCategory);\r
- textData.putText(Language.ENGLISH(), redBookCategory);\r
- td.addElement(textData);\r
- }\r
- }\r
-\r
-\r
-\r
-\r
- /** \r
- * Stores parent-child, synonym and common name relationships\r
- */\r
- @Override\r
- protected void secondPass(CyprusImportState state) {\r
-// CyprusRow cyprusRow = state.getCyprusRow();\r
- return;\r
- }\r
-\r
-\r
-\r
- /**\r
- * @param state\r
- * @param rank\r
- * @param taxonNameStr\r
- * @param authorStr\r
- * @param nameStatus\r
- * @param nc\r
- * @return\r
- */\r
- private TaxonBase createTaxon(CyprusImportState state, Rank rank, String taxonNameStr, \r
- Class statusClass, NomenclaturalCode nc) {\r
- TaxonBase taxonBase;\r
- NonViralName taxonNameBase = null;\r
- if (nc == NomenclaturalCode.ICVCN){\r
- logger.warn("ICVCN not yet supported");\r
- \r
- }else{\r
- taxonNameBase =(NonViralName) nc.getNewTaxonNameInstance(rank);\r
- //NonViralName nonViralName = (NonViralName)taxonNameBase;\r
- INonViralNameParser parser = nameParser;//NonViralNameParserImpl.NewInstance();\r
- taxonNameBase = (NonViralName<BotanicalName>)parser.parseFullName(taxonNameStr, nc, rank);\r
- \r
- //taxonNameBase.setNameCache(taxonNameStr);\r
- \r
- }\r
-\r
- //Create the taxon\r
- Reference sec = state.getConfig().getSourceReference();\r
- // Create the status\r
- if (statusClass.equals(Taxon.class)){\r
- taxonBase = Taxon.NewInstance(taxonNameBase, sec);\r
- }else if (statusClass.equals(Synonym.class)){\r
- taxonBase = Synonym.NewInstance(taxonNameBase, sec);\r
- }else {\r
- Taxon taxon = Taxon.NewInstance(taxonNameBase, sec);\r
- taxon.setTaxonStatusUnknown(true);\r
- taxonBase = taxon;\r
- }\r
- return taxonBase;\r
- }\r
-\r
- private boolean makeParent(CyprusImportState state, Taxon parentTaxon, Taxon childTaxon, Reference citation, String microCitation){\r
- boolean success = true;\r
- Reference sec = state.getConfig().getSourceReference();\r
- \r
-// Reference sec = parentTaxon.getSec();\r
- Classification tree = state.getTree(sec);\r
- if (tree == null){\r
- tree = makeTree(state, sec);\r
- tree.setTitleCache(state.getConfig().getSourceReferenceTitle());\r
- }\r
- if (sec.equals(childTaxon.getSec())){\r
- success &= (null != tree.addParentChild(parentTaxon, childTaxon, citation, microCitation));\r
- }else{\r
- logger.warn("No relationship added for child " + childTaxon.getTitleCache());\r
- }\r
- return success;\r
- }\r
- \r
-\r
- \r
-}\r
+/**
+ * Copyright (C) 2007 EDIT
+ * European Distributed Institute of Taxonomy
+ * http://www.e-taxonomy.eu
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * See LICENSE.TXT at the top of this package for the full license terms.
+ */
+
+package eu.etaxonomy.cdm.io.cyprus;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+
+import org.apache.commons.lang.StringUtils;
+import org.apache.log4j.Logger;
+import org.springframework.stereotype.Component;
+
+import eu.etaxonomy.cdm.common.CdmUtils;
+import eu.etaxonomy.cdm.io.common.TdwgAreaProvider;
+import eu.etaxonomy.cdm.io.common.mapping.IInputTransformer;
+import eu.etaxonomy.cdm.io.common.mapping.UndefinedTransformerMethodException;
+import eu.etaxonomy.cdm.io.excel.common.ExcelImporterBase;
+import eu.etaxonomy.cdm.model.common.Language;
+import eu.etaxonomy.cdm.model.description.Distribution;
+import eu.etaxonomy.cdm.model.description.Feature;
+import eu.etaxonomy.cdm.model.description.PresenceAbsenceTerm;
+import eu.etaxonomy.cdm.model.description.TaxonDescription;
+import eu.etaxonomy.cdm.model.description.TextData;
+import eu.etaxonomy.cdm.model.location.NamedArea;
+import eu.etaxonomy.cdm.model.name.INonViralName;
+import eu.etaxonomy.cdm.model.name.NomenclaturalCode;
+import eu.etaxonomy.cdm.model.name.Rank;
+import eu.etaxonomy.cdm.model.reference.Reference;
+import eu.etaxonomy.cdm.model.taxon.Classification;
+import eu.etaxonomy.cdm.model.taxon.Synonym;
+import eu.etaxonomy.cdm.model.taxon.SynonymType;
+import eu.etaxonomy.cdm.model.taxon.Taxon;
+import eu.etaxonomy.cdm.model.taxon.TaxonBase;
+import eu.etaxonomy.cdm.strategy.parser.INonViralNameParser;
+import eu.etaxonomy.cdm.strategy.parser.NonViralNameParserImpl;
+
+/**
+ * @author a.babadshanjan
+ * @created 08.01.2009
+ */
+
+@Component
+public class CyprusExcelImport extends ExcelImporterBase<CyprusImportState> {
+ private static final Logger logger = Logger.getLogger(CyprusExcelImport.class);
+
+ public static Set<String> validMarkers = new HashSet<String>(Arrays.asList(new String[]{"", "valid", "accepted", "a", "v", "t"}));
+ public static Set<String> synonymMarkers = new HashSet<String>(Arrays.asList(new String[]{"", "invalid", "synonym", "s", "i"}));
+
+
+ @Override
+ protected boolean isIgnore(CyprusImportState state) {
+ return ! state.getConfig().isDoTaxa();
+ }
+
+
+ /* (non-Javadoc)
+ * @see eu.etaxonomy.cdm.io.common.CdmIoBase#doCheck(eu.etaxonomy.cdm.io.common.IoStateBase)
+ */
+ @Override
+ protected boolean doCheck(CyprusImportState state) {
+ logger.warn("DoCheck not yet implemented for CyprusExcelImport");
+ return true;
+ }
+
+// protected static final String ID_COLUMN = "Id";
+ protected static final String SPECIES_COLUMN = "species";
+ protected static final String SUBSPECIES_COLUMN = "subspecies";
+ protected static final String GENUS_COLUMN = "genus";
+ protected static final String FAMILY_COLUMN = "family";
+ protected static final String DIVISION_COLUMN = "division";
+ protected static final String HOMOTYPIC_SYNONYM_COLUMN = "homotypic synonyms";
+ protected static final String HETEROTYPIC_SYNONYMS_COLUMN = "heterotypic synonyms";
+ protected static final String ENDEMISM_COLUMN = "endemism";
+
+ protected static final String STATUS_COLUMN = "status";
+ protected static final String RED_DATA_BOOK_CATEGORY_COLUMN = "red data book category";
+ protected static final String SYSTEMATICS_COLUMN = "systematics";
+
+
+
+ // TODO: This enum is for future use (perhaps).
+ protected enum Columns {
+// Id("Id"),
+ Species("species"),
+ Subspecies("subspecies"),
+ Genus("genus"),
+ Family("family"),
+ Division("division"),
+ HomotypicSynonyms("homotypic synonyms"),
+ HeterotypicSynonyms("heterotypic synonyms"),
+ Status("status"),
+ Endemism("endemism");
+
+ private final String head;
+ private String value;
+
+ private Columns(String head) {
+ this.head = head;
+ }
+
+ public String head() {
+ return this.head;
+ }
+
+ public String value() {
+ return this.value;
+ }
+ }
+
+
+ @Override
+ protected void analyzeRecord(HashMap<String, String> record, CyprusImportState state) {
+
+ Set<String> keys = record.keySet();
+
+ CyprusRow cyprusRow = new CyprusRow();
+ state.setCyprusRow(cyprusRow);
+
+ for (String originalKey: keys) {
+ Integer index = 0;
+ String indexedKey = CdmUtils.removeDuplicateWhitespace(originalKey.trim()).toString();
+ String[] split = indexedKey.split("_");
+ String key = split[0];
+ if (split.length > 1){
+ String indexString = split[1];
+ try {
+ index = Integer.valueOf(indexString);
+ } catch (NumberFormatException e) {
+ String message = "Index must be integer";
+ logger.error(message);
+ continue;
+ }
+ }
+
+ String value = record.get(indexedKey);
+ if (! StringUtils.isBlank(value)) {
+ if (logger.isDebugEnabled()) { logger.debug(key + ": " + value); }
+ value = CdmUtils.removeDuplicateWhitespace(value.trim()).toString();
+ }else{
+ continue;
+ }
+
+
+ if (key.equalsIgnoreCase(SPECIES_COLUMN)) {
+// int ivalue = floatString2IntValue(value);
+ cyprusRow.setSpecies(value);
+
+ } else if(key.equalsIgnoreCase(SUBSPECIES_COLUMN)) {
+ cyprusRow.setSubspecies(value);
+
+ } else if(key.equalsIgnoreCase(HOMOTYPIC_SYNONYM_COLUMN)) {
+ cyprusRow.setHomotypicSynonyms(value);
+
+ } else if(key.equalsIgnoreCase(HETEROTYPIC_SYNONYMS_COLUMN)) {
+ cyprusRow.setHeterotypicSynonyms(value);
+
+ } else if(key.equalsIgnoreCase(ENDEMISM_COLUMN)) {
+ cyprusRow.setEndemism(value);
+
+ } else if(key.equalsIgnoreCase(STATUS_COLUMN)) {
+ cyprusRow.setStatus(value);
+
+ } else if(key.equalsIgnoreCase(RED_DATA_BOOK_CATEGORY_COLUMN)) {
+ cyprusRow.setRedDataBookCategory(value);
+
+ } else if(key.equalsIgnoreCase(SYSTEMATICS_COLUMN)) {
+ cyprusRow.setSystematics(value);
+
+ } else if(key.equalsIgnoreCase(GENUS_COLUMN)) {
+ cyprusRow.setGenus(value);
+
+ } else if(key.equalsIgnoreCase(FAMILY_COLUMN)) {
+ cyprusRow.setFamily(value);
+
+ } else if(key.equalsIgnoreCase(DIVISION_COLUMN)) {
+ cyprusRow.setDivision(value);
+
+ } else {
+ state.setUnsuccessfull();
+ logger.error("Unexpected column header " + key);
+ }
+ }
+ return;
+ }
+
+ private static INonViralNameParser nameParser = NonViralNameParserImpl.NewInstance();
+ private static NomenclaturalCode nc = NomenclaturalCode.ICNAFP;
+ private Feature redBookCategory;
+ private Feature endemism;
+ private PresenceAbsenceTerm indigenous;
+ private PresenceAbsenceTerm indigenousDoubtful;
+ private PresenceAbsenceTerm cultivatedDoubtful;
+
+ private PresenceAbsenceTerm casual;
+ private PresenceAbsenceTerm casualDoubtful;
+ private PresenceAbsenceTerm nonInvasive;
+ private PresenceAbsenceTerm nonInvasiveDoubtful;
+ private PresenceAbsenceTerm invasive;
+ private PresenceAbsenceTerm invasiveDoubtful;
+ private PresenceAbsenceTerm questionable;
+ private PresenceAbsenceTerm questionableDoubtful;
+
+ private boolean termsCreated = false;
+
+ private boolean makeTerms(CyprusImportState state) {
+ if (termsCreated == false){
+ IInputTransformer transformer = state.getTransformer();
+
+ try {
+ //feature
+ UUID redBookUuid = transformer.getFeatureUuid("Red book");
+ redBookCategory = this.getFeature(state, redBookUuid, "Red book category", "Red data book category", "Red book", null);
+ getTermService().save(redBookCategory);
+
+ UUID endemismUuid = transformer.getFeatureUuid("Endemism");
+ endemism = this.getFeature(state, endemismUuid, "Endemism", "Endemism", "Endemism", null);
+ getTermService().save(endemism);
+
+ //status
+
+ UUID indigenousUuid = transformer.getPresenceTermUuid("IN");
+ indigenous = this.getPresenceTerm(state, indigenousUuid, "indigenous", "Indigenous", "IN", false);
+ getTermService().save(indigenous);
+ UUID indigenousDoubtfulUuid = transformer.getPresenceTermUuid("IN?");
+ indigenousDoubtful = this.getPresenceTerm(state, indigenousDoubtfulUuid, "indigenous?", "Indigenous?", "IN?", false);
+ getTermService().save(indigenousDoubtful);
+
+ UUID cultivatedDoubtfulUuid = transformer.getPresenceTermUuid("CU?");
+ cultivatedDoubtful = this.getPresenceTerm(state, cultivatedDoubtfulUuid, "cultivated?", "Cultivated?", "CU?", false);
+ getTermService().save(cultivatedDoubtful);
+
+
+ UUID casualUuid = transformer.getPresenceTermUuid("CA");
+ casual = this.getPresenceTerm(state, casualUuid, "casual", "Casual", "CA", false);
+ getTermService().save(casual);
+ UUID casualDoubtfulUuid = transformer.getPresenceTermUuid("CA?");
+ casualDoubtful = this.getPresenceTerm(state, casualDoubtfulUuid, "casual?", "Casual?", "CA?", false);
+ getTermService().save(casualDoubtful);
+
+
+ UUID nonInvasiveUuid = transformer.getPresenceTermUuid("NN");
+ nonInvasive = this.getPresenceTerm(state, nonInvasiveUuid, "naturalized non-invasive", "Naturalized non-invasive", "NN", false);
+ getTermService().save(nonInvasive);
+ UUID nonInvasiveDoubtfulUuid = transformer.getPresenceTermUuid("NN?");
+ nonInvasiveDoubtful = this.getPresenceTerm(state, nonInvasiveDoubtfulUuid, "naturalized non-invasive?", "Naturalized non-invasive?", "NN?", false);
+ getTermService().save(nonInvasiveDoubtful);
+
+ UUID invasiveUuid = transformer.getPresenceTermUuid("NA");
+ invasive = this.getPresenceTerm(state, invasiveUuid, "naturalized invasive", "Naturalized invasive", "NA", false);
+ getTermService().save(invasive);
+ UUID invasiveDoubtfulUuid = transformer.getPresenceTermUuid("NA?");
+ invasiveDoubtful = this.getPresenceTerm(state, invasiveDoubtfulUuid, "naturalized invasive?", "Naturalized invasive?", "NA?", false);
+ getTermService().save(invasiveDoubtful);
+
+ UUID questionableUuid = transformer.getPresenceTermUuid("Q");
+ questionable = this.getPresenceTerm(state, questionableUuid, "questionable", "Questionable", "Q", false);
+ getTermService().save(questionable);
+ UUID questionableDoubtfulUuid = transformer.getPresenceTermUuid("Q?");
+ questionableDoubtful = this.getPresenceTerm(state, questionableDoubtfulUuid, "questionable?", "Questionable?", "Q?", false);
+ getTermService().save(questionableDoubtful);
+
+ termsCreated = true;
+
+ return true;
+ } catch (UndefinedTransformerMethodException e) {
+ e.printStackTrace();
+ return false;
+ }
+ }
+ return true;
+
+ }
+
+ /**
+ * Stores taxa records in DB
+ */
+ @Override
+ protected void firstPass(CyprusImportState state) {
+
+ makeTerms(state);
+ CyprusRow taxonLight = state.getCyprusRow();
+ Reference citation = null;
+ String microCitation = null;
+
+ //species name
+ String speciesStr = taxonLight.getSpecies();
+ String subSpeciesStr = taxonLight.getSubspecies();
+ String homotypicSynonymsString = taxonLight.getHomotypicSynonyms();
+ List<String> homotypicSynonymList = Arrays.asList(homotypicSynonymsString.split(";"));
+ String heterotypicSynonymsString = taxonLight.getHeterotypicSynonyms();
+ List<String> heterotypicSynonymList = Arrays.asList(heterotypicSynonymsString.split(";"));
+
+ String systematicsString = taxonLight.getSystematics();
+ String endemismString = taxonLight.getEndemism();
+ String statusString = taxonLight.getStatus();
+ String redBookCategory = taxonLight.getRedDataBookCategory();
+
+ if (StringUtils.isNotBlank(speciesStr)) {
+ boolean speciesIsExisting = false;
+ Taxon mainTaxon = null;
+ //species
+ Taxon speciesTaxon = (Taxon)createTaxon(state, Rank.SPECIES(), speciesStr, Taxon.class, nc);
+ mainTaxon = speciesTaxon;
+
+ //subspecies
+ if (StringUtils.isNotBlank(subSpeciesStr)){
+ Taxon existingSpecies = state.getHigherTaxon(speciesStr);
+ if (existingSpecies != null){
+ speciesIsExisting = true;
+ speciesTaxon = existingSpecies;
+ }
+
+ Taxon subSpeciesTaxon = (Taxon)createTaxon(state, Rank.SUBSPECIES(), subSpeciesStr, Taxon.class, nc);
+
+ if (subSpeciesTaxon != null){
+ makeParent(state, speciesTaxon, subSpeciesTaxon, citation, microCitation);
+ }
+ mainTaxon = subSpeciesTaxon;
+ state.putHigherTaxon(speciesStr, speciesTaxon);
+ }
+
+ if (! speciesIsExisting){
+ makeHigherTaxa(state, taxonLight, speciesTaxon, citation, microCitation);
+ }
+ makeHomotypicSynonyms(state, homotypicSynonymList, mainTaxon);
+ makeHeterotypicSynonyms(state, heterotypicSynonymList, mainTaxon);
+ makeSystematics(systematicsString, mainTaxon);
+ makeEndemism(endemismString, mainTaxon);
+ makeStatus(statusString, mainTaxon);
+ makeRedBookCategory(redBookCategory, mainTaxon);
+
+// state.putHigherTaxon(higherName, uuid);//(speciesStr, mainTaxon);
+ getTaxonService().save(mainTaxon);
+ }
+ return;
+ }
+
+
+ private void makeHigherTaxa(CyprusImportState state, CyprusRow taxonLight, Taxon speciesTaxon, Reference citation, String microCitation) {
+ String divisionStr = taxonLight.getDivision();
+ String genusStr = taxonLight.getGenus();
+ String familyStr = taxonLight.getFamily();
+
+ Taxon division = getTaxon(state, divisionStr, Rank.DIVISION(), null, citation, microCitation);
+ Taxon family = getTaxon(state, familyStr, Rank.FAMILY(), division, citation, microCitation);
+ Taxon genus = getTaxon(state, genusStr, Rank.GENUS(), family, citation, microCitation);
+ makeParent(state, genus, speciesTaxon, citation, microCitation) ;
+ }
+
+
+ private Taxon getTaxon(CyprusImportState state, String taxonNameStr, Rank rank, Taxon parent, Reference citation, String microCitation) {
+ Taxon result;
+ if (state.containsHigherTaxon(taxonNameStr)){
+ result = state.getHigherTaxon(taxonNameStr);
+ }else{
+ result = (Taxon)createTaxon(state, rank, taxonNameStr, Taxon.class, nc);
+ state.putHigherTaxon(taxonNameStr, result);
+ if (parent == null){
+ makeParent(state, null,result, citation, microCitation);
+ }else{
+ makeParent(state, parent, result, citation, microCitation);
+ }
+
+ }
+ return result;
+ }
+
+
+ private void makeHomotypicSynonyms(CyprusImportState state,
+ List<String> homotypicSynonymList, Taxon mainTaxon) {
+ for (String homotypicSynonym: homotypicSynonymList){
+ if (StringUtils.isNotBlank(homotypicSynonym)){
+ Synonym synonym = (Synonym)createTaxon(state, null, homotypicSynonym, Synonym.class, nc);
+ mainTaxon.addHomotypicSynonym(synonym);
+ }
+ }
+ }
+
+
+ private void makeHeterotypicSynonyms(CyprusImportState state, List<String> heterotypicSynonymList, Taxon mainTaxon) {
+ for (String heterotypicSynonym: heterotypicSynonymList){
+ if (StringUtils.isNotBlank(heterotypicSynonym)){
+ Synonym synonym = (Synonym)createTaxon(state, null, heterotypicSynonym, Synonym.class, nc);
+ mainTaxon.addSynonym(synonym, SynonymType.HETEROTYPIC_SYNONYM_OF());
+ }
+ }
+ }
+
+
+ private void makeSystematics(String systematicsString, Taxon mainTaxon) {
+ //Systematics
+ if (StringUtils.isNotBlank(systematicsString)){
+ TaxonDescription td = this.getTaxonDescription(mainTaxon, false, true);
+ TextData textData = TextData.NewInstance(Feature.SYSTEMATICS());
+ textData.putText(Language.UNDETERMINED(), systematicsString);
+ td.addElement(textData);
+ }
+ }
+
+
+ private void makeEndemism(String endemismString, Taxon mainTaxon) {
+ //endemism
+ if (StringUtils.isNotBlank(endemismString)){
+ //OLD - not wanted as marker
+// boolean flag;
+// if (endemismString.trim().equalsIgnoreCase("not endemic") || endemismString.trim().equalsIgnoreCase("ne?")){
+// flag = false;
+// }else if (endemismString.trim().equalsIgnoreCase("endemic")){
+// flag = true;
+// }else{
+// throw new RuntimeException(endemismString + " is not a valid value for endemism");
+// }
+// Marker marker = Marker.NewInstance(MarkerType.ENDEMIC(), flag);
+// mainTaxon.addMarker(marker);
+ //text data
+ TaxonDescription td = this.getTaxonDescription(mainTaxon, false, true);
+ TextData textData = TextData.NewInstance(endemism);
+ textData.putText(Language.ENGLISH(), endemismString);
+ td.addElement(textData);
+ }
+ }
+
+
+ private void makeStatus(String statusString, Taxon mainTaxon) {
+ //status
+ if (StringUtils.isNotBlank(statusString)){
+ PresenceAbsenceTerm status = null;
+ if (statusString.contains("Indigenous?")){
+ status = indigenousDoubtful;
+ }else if (statusString.contains("Indigenous")){
+ status = indigenous;
+ }else if (statusString.contains("Casual?") || statusString.contains("Causal?")){
+ status = casualDoubtful;
+ }else if (statusString.contains("Casual")){
+ status = casual;
+ }else if (statusString.contains("Cultivated?")){
+ status = cultivatedDoubtful;
+ }else if (statusString.contains("Cultivated")){
+ status = PresenceAbsenceTerm.CULTIVATED();
+ }else if (statusString.contains("non-invasive?")){
+ status = nonInvasiveDoubtful;
+ }else if (statusString.contains("non-invasive")){
+ status = nonInvasive;
+ }else if (statusString.contains("invasive?")){
+ status = invasiveDoubtful;
+ }else if (statusString.contains("invasive")){
+ status = invasive;
+ }else if (statusString.contains("Questionable?")){
+ status = questionableDoubtful;
+ }else if (statusString.contains("Questionable")){
+ status = questionable;
+ }else if (statusString.startsWith("F")){
+ status = null;
+ }else if (statusString.equals("##")){
+ status = null;
+ }else{
+ logger.warn("Unknown status: " + statusString);
+ status = null;
+ }
+ TaxonDescription td = this.getTaxonDescription(mainTaxon, false, true);
+ NamedArea area = TdwgAreaProvider.getAreaByTdwgAbbreviation("CYP");
+ Distribution distribution = Distribution.NewInstance(area, status);
+ td.addElement(distribution);
+
+ //text data
+ TextData textData = TextData.NewInstance(Feature.STATUS());
+ textData.putText(Language.ENGLISH(), statusString);
+ td.addElement(textData);
+ }
+ }
+
+
+ private void makeRedBookCategory(String redBookCategory, Taxon mainTaxon) {
+ //red data book category
+ if (StringUtils.isNotBlank(redBookCategory)){
+ TaxonDescription td = this.getTaxonDescription(mainTaxon, false, true);
+ TextData textData = TextData.NewInstance(this.redBookCategory);
+ textData.putText(Language.ENGLISH(), redBookCategory);
+ td.addElement(textData);
+ }
+ }
+
+
+
+
+ /**
+ * Stores parent-child, synonym and common name relationships
+ */
+ @Override
+ protected void secondPass(CyprusImportState state) {
+// CyprusRow cyprusRow = state.getCyprusRow();
+ return;
+ }
+
+
+
+ /**
+ * @param state
+ * @param rank
+ * @param taxonNameStr
+ * @param authorStr
+ * @param nameStatus
+ * @param nc
+ * @return
+ */
+ private TaxonBase createTaxon(CyprusImportState state, Rank rank, String taxonNameStr,
+ Class statusClass, NomenclaturalCode nc) {
+ TaxonBase taxonBase;
+ INonViralName taxonNameBase = null;
+ if (nc == NomenclaturalCode.ICVCN){
+ logger.warn("ICVCN not yet supported");
+
+ }else{
+ taxonNameBase = nc.getNewTaxonNameInstance(rank);
+ INonViralNameParser<INonViralName> parser = nameParser;//NonViralNameParserImpl.NewInstance();
+ taxonNameBase = parser.parseFullName(taxonNameStr, nc, rank);
+
+ //taxonNameBase.setNameCache(taxonNameStr);
+
+ }
+
+ //Create the taxon
+ Reference sec = state.getConfig().getSourceReference();
+ // Create the status
+ if (statusClass.equals(Taxon.class)){
+ taxonBase = Taxon.NewInstance(taxonNameBase, sec);
+ }else if (statusClass.equals(Synonym.class)){
+ taxonBase = Synonym.NewInstance(taxonNameBase, sec);
+ }else {
+ Taxon taxon = Taxon.NewInstance(taxonNameBase, sec);
+ taxon.setTaxonStatusUnknown(true);
+ taxonBase = taxon;
+ }
+ return taxonBase;
+ }
+
+ private boolean makeParent(CyprusImportState state, Taxon parentTaxon, Taxon childTaxon, Reference citation, String microCitation){
+ boolean success = true;
+ Reference sec = state.getConfig().getSourceReference();
+
+// Reference sec = parentTaxon.getSec();
+ Classification tree = state.getTree(sec);
+ if (tree == null){
+ tree = makeTree(state, sec);
+ tree.setTitleCache(state.getConfig().getSourceReferenceTitle());
+ }
+ if (sec.equals(childTaxon.getSec())){
+ success &= (null != tree.addParentChild(parentTaxon, childTaxon, citation, microCitation));
+ }else{
+ logger.warn("No relationship added for child " + childTaxon.getTitleCache());
+ }
+ return success;
+ }
+
+
+
+}
BGBM BDI Projects / cdmlib-apps.git / blobdiff