From a917376bc95b2848fb41f3b94aa3310df91a0f7b Mon Sep 17 00:00:00 2001 From: =?utf8?q?Andreas=20M=C3=BCller?= Date: Tue, 8 Feb 2022 08:35:20 +0100 Subject: [PATCH] ref #9932 some very first versions of Mexico eflora import --- .../cdm/app/mexico/MexicoEfloraActivator.java | 116 +++++++ .../MexicoEfloraReferencesActivator.java | 19 ++ .../io/mexico/MexicoConabioTransformer.java | 5 +- .../cdm/io/mexico/MexicoEfloraImportBase.java | 148 +++++++++ .../MexicoEfloraImportConfigurator.java | 218 ++++++++++++++ .../io/mexico/MexicoEfloraImportState.java | 60 ++++ .../io/mexico/MexicoEfloraTaxonImport.java | 282 ++++++++++++++++++ 7 files changed, 847 insertions(+), 1 deletion(-) create mode 100644 app-import/src/main/java/eu/etaxonomy/cdm/app/mexico/MexicoEfloraActivator.java create mode 100644 app-import/src/main/java/eu/etaxonomy/cdm/app/mexico/MexicoEfloraReferencesActivator.java create mode 100644 app-import/src/main/java/eu/etaxonomy/cdm/io/mexico/MexicoEfloraImportBase.java create mode 100644 app-import/src/main/java/eu/etaxonomy/cdm/io/mexico/MexicoEfloraImportConfigurator.java create mode 100644 app-import/src/main/java/eu/etaxonomy/cdm/io/mexico/MexicoEfloraImportState.java create mode 100644 app-import/src/main/java/eu/etaxonomy/cdm/io/mexico/MexicoEfloraTaxonImport.java diff --git a/app-import/src/main/java/eu/etaxonomy/cdm/app/mexico/MexicoEfloraActivator.java b/app-import/src/main/java/eu/etaxonomy/cdm/app/mexico/MexicoEfloraActivator.java new file mode 100644 index 00000000..17d1236d --- /dev/null +++ b/app-import/src/main/java/eu/etaxonomy/cdm/app/mexico/MexicoEfloraActivator.java @@ -0,0 +1,116 @@ +// $Id$ +/** +* Copyright (C) 2022 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.app.mexico; + +import java.util.UUID; + +import org.apache.log4j.Logger; + +import eu.etaxonomy.cdm.app.common.CdmDestinations; +import eu.etaxonomy.cdm.common.URI; +import eu.etaxonomy.cdm.database.DbSchemaValidation; +import eu.etaxonomy.cdm.database.ICdmDataSource; +import eu.etaxonomy.cdm.io.common.CdmDefaultImport; +import eu.etaxonomy.cdm.io.common.IImportConfigurator.CHECK; +import eu.etaxonomy.cdm.io.mexico.MexicoConabioTransformer; +import eu.etaxonomy.cdm.io.mexico.MexicoEfloraImportConfigurator; +import eu.etaxonomy.cdm.model.reference.Reference; +import eu.etaxonomy.cdm.model.reference.ReferenceFactory; + +/** + * See #9932. + * + * @author a.mueller + * @date 29.01.2022 + */ +public class MexicoEfloraActivator { + + private static final Logger logger = Logger.getLogger(MexicoBorhidiActivator.class); + + //database validation status (create, update, validate ...) + static DbSchemaValidation hbm2dll = DbSchemaValidation.CREATE; + + //static final ICdmDataSource cdmDestination = CdmDestinations.localH2(); + static final ICdmDataSource cdmDestination = CdmDestinations.cdm_test_local_mysql_test(); + + //feature tree uuid + public static final UUID featureTreeUuid = UUID.fromString("7cfa2122-043d-4e96-922c-356fc04d68a3"); + + //classification + static final UUID classificationUuid = UUID.fromString("28abf7da-e0ad-48ca-b26c-9f276dd90267"); + private static final String classificationName = "Mexico Eflora"; + + //check - import + static final CHECK check = CHECK.IMPORT_WITHOUT_CHECK; + + boolean doVocabularies = (hbm2dll == DbSchemaValidation.CREATE); +// static final boolean doTaxa = false; +// static final boolean doDeduplicate = true; + + protected void doImport(ICdmDataSource cdmDestination){ + + URI source = borhidi(); + + //make Source + MexicoEfloraImportConfigurator config= MexicoEfloraImportConfigurator.NewInstance(source, cdmDestination); + config.setClassificationUuid(classificationUuid); + config.setClassificationName(classificationName); + config.setCheck(check); + config.setDbSchemaValidation(hbm2dll); + config.setSecReference(getSecReference()); + + config.setSource(source); + String fileName = source.toString(); + fileName = fileName.substring(fileName.lastIndexOf("/") + 1 ); + + String message = "Start import from ("+ fileName + ") ..."; + System.out.println(message); + logger.warn(message); + + config.setSourceReference(getSourceReference()); + + CdmDefaultImport myImport = new CdmDefaultImport<>(); + + myImport.invoke(config); + + System.out.println("End import from ("+ source.toString() + ")..."); + + } + + + //Mexico eflora + public static URI borhidi() { + return URI.create("file:////BGBM-PESIHPC/Mexico/Borhidi_2012.xlsx"); + } + + + private Reference getSourceReference() { + Reference result = ReferenceFactory.newDatabase(); + result.setTitle("CONABIO Eflora"); +// Person borhidi = Person.NewTitledInstance("Borhidi"); +// borhidi.setGivenName("Attila"); +// result.setAuthorship(borhidi); + return result; + } + + private Reference getSecReference() { + Reference result = ReferenceFactory.newBook(); + result.setTitle("Mexico Eflora"); + //TODO + result.setUuid(MexicoConabioTransformer.uuidReferenceEflora); + return result; + } + + public static void main(String[] args) { + MexicoBorhidiActivator me = new MexicoBorhidiActivator(); + me.doImport(cdmDestination); + System.exit(0); + } +} diff --git a/app-import/src/main/java/eu/etaxonomy/cdm/app/mexico/MexicoEfloraReferencesActivator.java b/app-import/src/main/java/eu/etaxonomy/cdm/app/mexico/MexicoEfloraReferencesActivator.java new file mode 100644 index 00000000..b94aca93 --- /dev/null +++ b/app-import/src/main/java/eu/etaxonomy/cdm/app/mexico/MexicoEfloraReferencesActivator.java @@ -0,0 +1,19 @@ +// $Id$ +/** +* Copyright (C) 2022 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.app.mexico; + +/** + * @author a.mueller + * @date 29.01.2022 + * + */ +public class MexicoEfloraReferencesActivator { + +} diff --git a/app-import/src/main/java/eu/etaxonomy/cdm/io/mexico/MexicoConabioTransformer.java b/app-import/src/main/java/eu/etaxonomy/cdm/io/mexico/MexicoConabioTransformer.java index 369156df..6383e728 100644 --- a/app-import/src/main/java/eu/etaxonomy/cdm/io/mexico/MexicoConabioTransformer.java +++ b/app-import/src/main/java/eu/etaxonomy/cdm/io/mexico/MexicoConabioTransformer.java @@ -28,8 +28,11 @@ public class MexicoConabioTransformer extends InputTransformerBase{ private static final Logger logger = Logger.getLogger(MexicoConabioTransformer.class); + public static UUID uuidReferenceEflora = UUID.fromString("0a04f189-b014-41b3-8a59-40f2f56a3087"); + + public static UUID uuidReferenceBorhidi = UUID.fromString("f76a535b-a1fd-437c-a09d-f94eddae2b5e"); -// public static UUID uuidReferenceConabio = UUID.fromString("7183652f-d7ca-45a7-9383-265996d3d10f"); + // public static UUID uuidReferenceConabio = UUID.fromString("7183652f-d7ca-45a7-9383-265996d3d10f"); public static UUID uuidReferenceConabio2 = UUID.fromString("292d0470-74b1-4419-84c5-0315a3bfe643"); public static final UUID uuidConabioIdIdentifierType = UUID.fromString("025fb8fe-e8e8-4136-bf37-93367a268889"); diff --git a/app-import/src/main/java/eu/etaxonomy/cdm/io/mexico/MexicoEfloraImportBase.java b/app-import/src/main/java/eu/etaxonomy/cdm/io/mexico/MexicoEfloraImportBase.java new file mode 100644 index 00000000..b2fe509c --- /dev/null +++ b/app-import/src/main/java/eu/etaxonomy/cdm/io/mexico/MexicoEfloraImportBase.java @@ -0,0 +1,148 @@ +/** +* 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.mexico; + +import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.Timestamp; +import java.util.Map; + +import org.apache.log4j.Logger; +import org.joda.time.DateTime; + +import eu.etaxonomy.cdm.common.CdmUtils; +import eu.etaxonomy.cdm.io.berlinModel.in.BerlinModelImportState; +import eu.etaxonomy.cdm.io.common.DbImportBase; +import eu.etaxonomy.cdm.io.common.ICdmIO; +import eu.etaxonomy.cdm.io.common.IPartitionedIO; +import eu.etaxonomy.cdm.model.common.IdentifiableSource; +import eu.etaxonomy.cdm.model.reference.ISourceable; +import eu.etaxonomy.cdm.model.reference.Reference; +import eu.etaxonomy.cdm.model.taxon.Taxon; +import eu.etaxonomy.cdm.model.taxon.TaxonBase; + +/** + * @author a.mueller + * @since 20.03.2008 + */ +public abstract class MexicoEfloraImportBase + extends DbImportBase + implements ICdmIO, IPartitionedIO { + + private static final long serialVersionUID = -5229728676004248450L; + private static final Logger logger = Logger.getLogger(MexicoEfloraImportBase.class); + + public MexicoEfloraImportBase(String tableName, String pluralString ) { + super(tableName, pluralString); + } + + @Override + protected String getIdQuery(BerlinModelImportState state){ + String result = " SELECT " + getTableName() + "id FROM " + getTableName(); + return result; + } + + //can be overriden + protected String getIdInSource(BerlinModelImportState state, ResultSet rs) throws SQLException { + return null; + } + + private DateTime getDateTime(Object timeString){ + if (timeString == null){ + return null; + } + DateTime dateTime = null; + if (timeString instanceof Timestamp){ + Timestamp timestamp = (Timestamp)timeString; + dateTime = new DateTime(timestamp); + }else{ + logger.warn("time ("+timeString+") is not a timestamp. Datetime set to current date. "); + dateTime = new DateTime(); + } + return dateTime; + } + + + protected Taxon getTaxon(BerlinModelImportState state, int taxonId, Map taxonMap, int factId) { + TaxonBase taxonBase = taxonMap.get(String.valueOf(taxonId)); + + //TODO for testing +// if (taxonBase == null && ! state.getConfig().isDoTaxa()){ +// taxonBase = Taxon.NewInstance(TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES()), null); +// } + + Taxon taxon; + if ( taxonBase instanceof Taxon ) { + taxon = (Taxon) taxonBase; + } else if (taxonBase != null) { + logger.warn("TaxonBase (" + taxonId + ") for Fact(Specimen) with factId " + factId + " was not of type Taxon but: " + taxonBase.getClass().getSimpleName()); + return null; + } else { + logger.warn("TaxonBase (" + taxonId + ") for Fact(Specimen) with factId " + factId + " is null."); + return null; + } + return taxon; + } + + + /** + * Searches first in the detail maps then in the ref maps for a reference. + * Returns the reference as soon as it finds it in one of the map, according + * to the order of the map. + * If nomRefDetailFk is null no search on detail maps is performed. + * If one of the maps is null no search on the according map is + * performed.
+ * You may define the order of search by the order you pass the maps but + * make sure to always pass the detail maps first. + * @param firstDetailMap + * @param secondDetailMap + * @param firstRefMap + * @param secondRefMap + * @param nomRefDetailFk + * @param nomRefFk + * @return + */ + protected Reference getReferenceFromMaps( + Map detailMap, + Map refMap, + String nomRefDetailFk, + String nomRefFk) { + Reference ref = null; + if (detailMap != null){ + ref = detailMap.get(nomRefDetailFk); + } + if (ref == null){ + ref = refMap.get(nomRefFk); + } + return ref; + } + + protected Reference getSourceReference(Reference sourceReference) { + Reference persistentSourceReference = getReferenceService().find(sourceReference.getUuid()); //just to be sure + if (persistentSourceReference != null){ + sourceReference = persistentSourceReference; + } + return sourceReference; + } + + protected static boolean importSourceExists(ISourceable sourceable, String idInSource, + String namespace, Reference ref) { + for (T source : sourceable.getSources()){ + if (CdmUtils.nullSafeEqual(namespace, source.getIdNamespace()) && + CdmUtils.nullSafeEqual(idInSource, source.getIdInSource()) && + CdmUtils.nullSafeEqual(ref, source.getCitation())){ + return true; + } + } + return false; + } + + +} diff --git a/app-import/src/main/java/eu/etaxonomy/cdm/io/mexico/MexicoEfloraImportConfigurator.java b/app-import/src/main/java/eu/etaxonomy/cdm/io/mexico/MexicoEfloraImportConfigurator.java new file mode 100644 index 00000000..b60cf55c --- /dev/null +++ b/app-import/src/main/java/eu/etaxonomy/cdm/io/mexico/MexicoEfloraImportConfigurator.java @@ -0,0 +1,218 @@ +/** +* 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.mexico; + +import java.util.UUID; + +import org.apache.log4j.Logger; + +import eu.etaxonomy.cdm.database.ICdmDataSource; +import eu.etaxonomy.cdm.io.berlinModel.in.BerlinModelAuthorImport; +import eu.etaxonomy.cdm.io.berlinModel.in.BerlinModelUserImport; +import eu.etaxonomy.cdm.io.berlinModel.in.validation.BerlinModelGeneralImportValidator; +import eu.etaxonomy.cdm.io.common.DbImportConfiguratorBase; +import eu.etaxonomy.cdm.io.common.Source; +import eu.etaxonomy.cdm.io.common.mapping.IInputTransformer; +import eu.etaxonomy.cdm.model.name.NomenclaturalCode; + +/** + * Configurator for Mexico Eflora import. + * + * @author a.mueller + * @date 29.01.2022 + */ +public class MexicoEfloraImportConfigurator + extends DbImportConfiguratorBase{ + + private static final long serialVersionUID = 70300913255425256L; + + @SuppressWarnings("unused") + private static Logger logger = Logger.getLogger(MexicoEfloraImportConfigurator.class); + + public static MexicoEfloraImportConfigurator NewInstance(Source berlinModelSource, ICdmDataSource destination){ + return new MexicoEfloraImportConfigurator(berlinModelSource, destination); + } + + //TODO + private static IInputTransformer defaultTransformer = null; + + private boolean doNameStatus = true; + private boolean doCommonNames = true; + private boolean doOccurrence = true; + private boolean doOccurrenceSources = true; + private boolean doMarker = true; + private boolean doUser = true; + private boolean doFacts = true; + private boolean doNameFacts = true; + private boolean doAuthors = true; + private DO_REFERENCES doReferences = DO_REFERENCES.ALL; + private boolean doTaxonNames = true; + private boolean doTypes = true; + private boolean doNamedAreas = true; + + //taxa + private boolean doTaxa = true; + private boolean doRelTaxa = true; + + + private UUID featureTreeUuid; + private String featureTreeTitle; + + @Override + protected void makeIoClassList(){ + ioClassList = new Class[]{ + BerlinModelGeneralImportValidator.class + , BerlinModelUserImport.class + , BerlinModelAuthorImport.class + }; + } + + @Override + public MexicoEfloraImportState getNewState() { + return new MexicoEfloraImportState(this); + } + + protected MexicoEfloraImportConfigurator(Source berlinModelSource, ICdmDataSource destination) { + super(berlinModelSource, destination, NomenclaturalCode.ICNAFP, defaultTransformer); //default for Berlin Model + } + + + public boolean isDoNameStatus() { + return doNameStatus; + } + public void setDoNameStatus(boolean doNameStatus) { + this.doNameStatus = doNameStatus; + } + + + public boolean isDoCommonNames() { + return doCommonNames; + } + + + /** + * @param doCommonNames + */ + public void setDoCommonNames(boolean doCommonNames) { + this.doCommonNames = doCommonNames; + + } + + public boolean isDoFacts() { + return doFacts; + } + public void setDoFacts(boolean doFacts) { + this.doFacts = doFacts; + } + + + public boolean isDoOccurrence() { + return doOccurrence; + } + public void setDoOccurrence(boolean doOccurrence) { + this.doOccurrence = doOccurrence; + } + + public boolean isDoOccurrenceSources() { + return doOccurrenceSources; + } + public void setDoOccurrenceSources(boolean doOccurrenceSources) { + this.doOccurrenceSources = doOccurrenceSources; + } + + + public boolean isDoMarker() { + return doMarker; + } + + public void setDoMarker(boolean doMarker) { + this.doMarker = doMarker; + } + + public boolean isDoUser() { + return doUser; + } + public void setDoUser(boolean doUser) { + this.doUser = doUser; + } + + public boolean isDoNameFacts() { + return doNameFacts; + } + public void setDoNameFacts(boolean doNameFacts) { + this.doNameFacts = doNameFacts; + } + + public boolean isDoAuthors() { + return doAuthors; + } + public void setDoAuthors(boolean doAuthors) { + this.doAuthors = doAuthors; + } + + public DO_REFERENCES getDoReferences() { + return doReferences; + } + public void setDoReferences(DO_REFERENCES doReferences) { + this.doReferences = doReferences; + } + + public boolean isDoTaxonNames() { + return doTaxonNames; + } + public void setDoTaxonNames(boolean doTaxonNames) { + this.doTaxonNames = doTaxonNames; + } + + public boolean isDoTypes() { + return doTypes; + } + public void setDoTypes(boolean doTypes) { + this.doTypes = doTypes; + } + + public boolean isDoTaxa() { + return doTaxa; + } + public void setDoTaxa(boolean doTaxa) { + this.doTaxa = doTaxa; + } + + public boolean isDoRelTaxa() { + return doRelTaxa; + } + public void setDoRelTaxa(boolean doRelTaxa) { + this.doRelTaxa = doRelTaxa; + } + + public UUID getFeatureTreeUuid() { + return featureTreeUuid; + } + public void setFeatureTreeUuid(UUID featureTreeUuid) { + this.featureTreeUuid = featureTreeUuid; + } + + @Override + public String getFeatureTreeTitle() { + return featureTreeTitle; + } + @Override + public void setFeatureTreeTitle(String featureTreeTitle) { + this.featureTreeTitle = featureTreeTitle; + } + + public boolean isDoNamedAreas() { + return doNamedAreas; + } + public void setDoNamedAreas(boolean doNamedAreas) { + this.doNamedAreas = doNamedAreas; + } + +} diff --git a/app-import/src/main/java/eu/etaxonomy/cdm/io/mexico/MexicoEfloraImportState.java b/app-import/src/main/java/eu/etaxonomy/cdm/io/mexico/MexicoEfloraImportState.java new file mode 100644 index 00000000..1fafa253 --- /dev/null +++ b/app-import/src/main/java/eu/etaxonomy/cdm/io/mexico/MexicoEfloraImportState.java @@ -0,0 +1,60 @@ +/** +* 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.mexico; + +import java.util.HashMap; +import java.util.Map; + +import org.apache.log4j.Logger; + +import eu.etaxonomy.cdm.io.common.DbImportStateBase; +import eu.etaxonomy.cdm.model.term.DefinedTermBase; + +/** + * State for Mexico Eflora import. + * + * @author a.mueller + * @date 29.01.2022 + * + */ +public class MexicoEfloraImportState + extends DbImportStateBase{ + + @SuppressWarnings("unused") + private static final Logger logger = Logger.getLogger(MexicoEfloraImportState.class); + + private Map dbCdmDefTermMap = new HashMap<>(); + + private boolean isReferenceSecondPath = false; + + public MexicoEfloraImportState(MexicoEfloraImportConfigurator config) { + super(config); + } + + public Map getDbCdmDefinedTermMap(){ + return this.dbCdmDefTermMap; + } + + public void putDefinedTermToMap(String tableName, String id, DefinedTermBase term){ + this.dbCdmDefTermMap.put(tableName + "_" + id, term); + } + + public void putDefinedTermToMap(String tableName, int id, DefinedTermBase term){ + putDefinedTermToMap(tableName, String.valueOf(id), term); + } + + public boolean isReferenceSecondPath() { + return isReferenceSecondPath; + } + + public void setReferenceSecondPath(boolean isReferenceSecondPath) { + this.isReferenceSecondPath = isReferenceSecondPath; + } +} diff --git a/app-import/src/main/java/eu/etaxonomy/cdm/io/mexico/MexicoEfloraTaxonImport.java b/app-import/src/main/java/eu/etaxonomy/cdm/io/mexico/MexicoEfloraTaxonImport.java new file mode 100644 index 00000000..4346a1de --- /dev/null +++ b/app-import/src/main/java/eu/etaxonomy/cdm/io/mexico/MexicoEfloraTaxonImport.java @@ -0,0 +1,282 @@ +/** +* 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.mexico; + +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Map; +import java.util.Set; + +import org.apache.commons.lang.StringUtils; +import org.apache.log4j.Logger; +import org.springframework.stereotype.Component; + +import eu.etaxonomy.cdm.database.update.DatabaseTypeNotSupportedException; +import eu.etaxonomy.cdm.io.berlinModel.in.BerlinModelImportState; +import eu.etaxonomy.cdm.io.berlinModel.in.BerlinModelReferenceImport; +import eu.etaxonomy.cdm.io.berlinModel.in.BerlinModelTaxonNameImport; +import eu.etaxonomy.cdm.io.common.ResultSetPartitioner; +import eu.etaxonomy.cdm.model.common.CdmBase; +import eu.etaxonomy.cdm.model.common.Language; +import eu.etaxonomy.cdm.model.description.Feature; +import eu.etaxonomy.cdm.model.description.TaxonDescription; +import eu.etaxonomy.cdm.model.description.TextData; +import eu.etaxonomy.cdm.model.name.Rank; +import eu.etaxonomy.cdm.model.name.TaxonName; +import eu.etaxonomy.cdm.model.reference.Reference; +import eu.etaxonomy.cdm.model.taxon.Synonym; +import eu.etaxonomy.cdm.model.taxon.Taxon; +import eu.etaxonomy.cdm.model.taxon.TaxonBase; +import eu.etaxonomy.cdm.model.term.DefinedTerm; +import eu.etaxonomy.cdm.strategy.parser.NonViralNameParserImpl; + + +/** + * @author a.mueller + * @since 20.03.2008 + */ +@Component +public class MexicoEfloraTaxonImport extends MexicoEfloraImportBase { + + private static final long serialVersionUID = -1186364983750790695L; + + private static final Logger logger = Logger.getLogger(MexicoEfloraTaxonImport.class); + + public static final String NAMESPACE = "Taxon"; + + private static final String pluralString = "Taxa"; + private static final String dbTableName = "Efloa_Taxonomia4CDM "; + + private static final String LAST_SCRUTINY_FK = "lastScrutinyFk"; + + /** + * How should the publish flag in table PTaxon be interpreted + * NO_MARKER: No marker is set + * ONLY_FALSE: + */ + public enum PublishMarkerChooser{ + NO_MARKER, + ONLY_FALSE, + ONLY_TRUE, + ALL; + + boolean doMark(boolean value){ + if (value == true){ + return this == ALL || this == ONLY_TRUE; + }else{ + return this == ALL || this == ONLY_FALSE; + } + } + } + + public MexicoEfloraTaxonImport(){ + super(dbTableName, pluralString); + } + + @Override + protected String getIdQuery(BerlinModelImportState state) { + String sql = " SELECT IdCAT " + + " FROM " + dbTableName + + " ORDER BY IdCAT "; + return sql; + } + + @Override + protected String getRecordQuery(MexicoEfloraImportConfigurator config) { + String sqlSelect = " SELECT * "; + String sqlFrom = " FROM " + dbTableName; + String sqlWhere = " WHERE ( IdCAT IN (" + ID_LIST_TOKEN + ") )"; + + String strRecordQuery =sqlSelect + " " + sqlFrom + " " + sqlWhere ; + return strRecordQuery; + } + + @Override + protected boolean doCheck(MexicoEfloraImportState state){ + //IOValidator validator = new BerlinModelTaxonImportValidator(); + //return validator.validate(state); + return true; + } + + @Override + public boolean doPartition(@SuppressWarnings("rawtypes") ResultSetPartitioner partitioner, MexicoEfloraImportState state) { + + boolean success = true ; + MexicoEfloraImportConfigurator config = state.getConfig(); + @SuppressWarnings("rawtypes") + Set taxaToSave = new HashSet<>(); +// @SuppressWarnings("unchecked") +// Map taxonNameMap = partitioner.getObjectMap(BerlinModelTaxonNameImport.NAMESPACE); + @SuppressWarnings("unchecked") + Map refMap = partitioner.getObjectMap(BerlinModelReferenceImport.REFERENCE_NAMESPACE); + + ResultSet rs = partitioner.getResultSet(); + try{ + while (rs.next()){ + + // if ((i++ % modCount) == 0 && i!= 1 ){ logger.info("PTaxa handled: " + (i-1));} + + //create TaxonName element + String taxonId = rs.getString("IdCAT"); + String status = rs.getString("EstatusNombre"); + String rankStr = rs.getString("CategoriaTaxonomica"); + String nameStr = rs.getString("Nombre"); + String autorStr = rs.getString("AutorSinAnio"); + String fullNameStr = nameStr + " " + autorStr; + String annotationStr = rs.getString("AnotacionTaxon"); +// String type = rs.getString("NomPublicationType"); + String year = rs.getString("Anio"); + int secFk = rs.getInt("IdBibliografiaSec"); + int nameId = rs.getInt("idNombre"); + + + //IdCATRel => Accepted Taxon => TaxonRel + //IdCAT_AscendenteHerarquico4CDM => Parent => TaxonRel + //IdCAT_BasNomOrig => Basionyme der akzeptierten Taxa => TaxonRel + + Rank rank = Rank.GENUS(); //FIXME + NonViralNameParserImpl parser = NonViralNameParserImpl.NewInstance(); + TaxonName taxonName = (TaxonName)parser.parseFullName(fullNameStr); + + String refFkStr = String.valueOf(secFk); + Reference sec = refMap.get(refFkStr); + + TaxonBase taxonBase; + Synonym synonym; + Taxon taxon; + try { + if ("aceptado".equals(status)){ + taxon = Taxon.NewInstance(taxonName, sec); + taxonBase = taxon; + }else if ("sinónimo".equals(status)){ + synonym = Synonym.NewInstance(taxonName, sec); + taxonBase = synonym; + }else { + logger.error("Status not yet implemented: " + status); + } + + + DefinedTerm taxonIdType = DefinedTerm.IDENTIFIER_NAME_IPNI(); + taxonBase.addIdentifier(taxonId, taxonIdType); + + //namePhrase + String namePhrase = rs.getString("NamePhrase"); + if (StringUtils.isNotBlank(namePhrase)){ + taxonBase.setAppendedPhrase(namePhrase); + } + + //Notes + boolean excludeNotes = state.getConfig().isTaxonNoteAsFeature() && taxonBase.isInstanceOf(Taxon.class); + String notes = rs.getString("Notes"); + + doIdCreatedUpdatedNotes(state, taxonBase, rs, taxonId, NAMESPACE, false, excludeNotes || notes == null); + if (excludeNotes && notes != null){ + makeTaxonomicNote(state, CdmBase.deproxy(taxonBase, Taxon.class), rs.getString("Notes")); + } + + partitioner.startDoSave(); + taxaToSave.add(taxonBase); + } catch (Exception e) { + logger.warn("An exception (" +e.getMessage()+") occurred when creating taxon with id " + taxonId + ". Taxon could not be saved."); + success = false; + } + } + } catch (DatabaseTypeNotSupportedException e) { + logger.error("MethodNotSupportedException:" + e); + return false; + } catch (Exception e) { + logger.error("SQLException:" + e); + return false; + } + + getTaxonService().save(taxaToSave); + return success; + } + + private boolean isMclIdentifier(BerlinModelImportState state, ResultSet rs, String idInSource) throws SQLException { + if (idInSource.contains("-")){ + return true; + }else if (idInSource.matches("(293|303)")){ + String created = rs.getString("Created_Who"); + if (created.endsWith(".xml")){ + return true; + } + } + return false; + } + + @Override + protected String getIdInSource(BerlinModelImportState state, ResultSet rs) throws SQLException { + String id = rs.getString("idInSource"); + return id; + } + + private void makeTaxonomicNote(BerlinModelImportState state, Taxon taxon, String notes) { + if (isNotBlank(notes)){ + TaxonDescription desc = getTaxonDescription(taxon, false, true); + desc.setDefault(true); //hard coded for Salvador, not used elsewhere as far as I can see + TextData textData = TextData.NewInstance(Feature.NOTES() , notes, Language.SPANISH_CASTILIAN(), null); + desc.addElement(textData); + } + } + + @Override + public Map> getRelatedObjectsForPartition(ResultSet rs, BerlinModelImportState state) { + + String nameSpace; + Set idSet; + Map> result = new HashMap<>(); + + try{ + Set nameIdSet = new HashSet<>(); + Set referenceIdSet = new HashSet<>(); + while (rs.next()){ + handleForeignKey(rs, nameIdSet, "PTNameFk"); + handleForeignKey(rs, referenceIdSet, "PTRefFk"); + if (state.getConfig().isUseLastScrutinyAsSec() && resultSetHasColumn(rs, LAST_SCRUTINY_FK)){ + handleForeignKey(rs, referenceIdSet, LAST_SCRUTINY_FK); + } + } + + //name map + nameSpace = BerlinModelTaxonNameImport.NAMESPACE; + idSet = nameIdSet; + Map nameMap = getCommonService().getSourcedObjectsByIdInSourceC(TaxonName.class, idSet, nameSpace); + result.put(nameSpace, nameMap); + + //reference map + nameSpace = BerlinModelReferenceImport.REFERENCE_NAMESPACE; + idSet = referenceIdSet; + Map referenceMap = getCommonService().getSourcedObjectsByIdInSourceC(Reference.class, idSet, nameSpace); + result.put(nameSpace, referenceMap); + + } catch (SQLException e) { + throw new RuntimeException(e); + } + return result; + } + + @Override + protected String getTableName() { + return dbTableName; + } + + @Override + public String getPluralString() { + return pluralString; + } + + @Override + protected boolean isIgnore(MexicoEfloraImportState state){ + return ! state.getConfig().isDoTaxa(); + } +} \ No newline at end of file -- 2.34.1