return makeDestination(dbType, cdmServer, cdmDB, -1, cdmUserName, null);
}
+ public static ICdmDataSource cdm_local_mexico(){
+ DatabaseTypeEnum dbType = DatabaseTypeEnum.MySQL;
+ String cdmServer = "127.0.0.1";
+ String cdmDB = "cdm_mexico";
+ String cdmUserName = "edit";
+ return makeDestination(dbType, cdmServer, cdmDB, -1, cdmUserName, null);
+ }
+ public static ICdmDataSource cdm_local_mexico2(){
+ DatabaseTypeEnum dbType = DatabaseTypeEnum.MySQL;
+ String cdmServer = "127.0.0.1";
+ String cdmDB = "cdm_mexico2";
+ String cdmUserName = "edit";
+ return makeDestination(dbType, cdmServer, cdmDB, -1, cdmUserName, null);
+ }
+
public static ICdmDataSource cdm_local_palmae(){
DatabaseTypeEnum dbType = DatabaseTypeEnum.MySQL;
String cdmServer = "127.0.0.1";
*/
package eu.etaxonomy.cdm.app.mexico;
-import eu.etaxonomy.cdm.common.URI;
import java.util.UUID;
import org.apache.log4j.Logger;
import eu.etaxonomy.cdm.api.application.ICdmRepository;
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.mexico.MexicoConabioImportConfigurator;
import eu.etaxonomy.cdm.io.mexico.MexicoConabioTransformer;
import eu.etaxonomy.cdm.model.agent.Institution;
-import eu.etaxonomy.cdm.model.agent.Person;
import eu.etaxonomy.cdm.model.common.Language;
import eu.etaxonomy.cdm.model.common.VerbatimTimePeriod;
import eu.etaxonomy.cdm.model.description.Feature;
static DbSchemaValidation hbm2dll = DbSchemaValidation.VALIDATE;
// static final ICdmDataSource cdmDestination = CdmDestinations.localH2();
-// static final ICdmDataSource cdmDestination = CdmDestinations.cdm_test_local_mysql_test();
- static final ICdmDataSource cdmDestination = CdmDestinations.cdm_production_mexico_rubiaceae();
+ static final ICdmDataSource cdmDestination = CdmDestinations.cdm_local_mexico();
+// static final ICdmDataSource cdmDestination = CdmDestinations.cdm_production_mexico_rubiaceae();
static final boolean doTaxa = true;
static final boolean doDistributions = true;
public static final UUID featureTreeUuid = UUID.fromString("d1f4ed29-9aae-4f6e-aa1e-4a3bf780e11d");
//classification
- static final UUID classificationUuid = UUID.fromString("61968b43-e881-4043-b5c2-ba192e8f72dc");
- private static final String classificationName = "Rubiaceae Conabio";
+ static final UUID classificationUuid = UUID.fromString("4ae5cc80-d06b-4102-a154-a5bc525e61d6");
+ private static final String classificationName = "IBUNAM";
//check - import
static final CHECK check = CHECK.IMPORT_WITHOUT_CHECK;
myImport.invoke(config);
- if (true){
+ if (hbm2dll == DbSchemaValidation.CREATE){
TermTree<Feature> tree = makeFeatureNodes(myImport.getCdmAppController());
- myImport.getCdmAppController().getFeatureTreeService().saveOrUpdate(tree);
+ myImport.getCdmAppController().getTermTreeService().saveOrUpdate(tree);
}
System.out.println("End import from ("+ source.toString() + ")...");
//Conabio Rubiaceae
public static URI conabio_rubiaceae() {
- return URI.create("file:////BGBM-PESIHPC/Mexico/CONABIO-Rubiaceae.xlsx");
+// return URI.create("file:////BGBM-PESIHPC/Mexico/Orchidaceae.xlsx");
+// return URI.create("file:////BGBM-PESIHPC/Mexico/Hydrocharitaceae.xlsx");
+// return URI.create("file:////BGBM-PESIHPC/Mexico/Ebenaceae.xlsx");
+// return URI.create("file:////BGBM-PESIHPC/Mexico/Annonaceae.xlsx");
+// return URI.create("file:////BGBM-PESIHPC/Mexico/Amaranthaceae.xlsx");
+// return URI.create("file:////BGBM-PESIHPC/Mexico/Rubiaceae.xlsx");
+ return URI.create("file:////BGBM-PESIHPC/Mexico/TaxonomyInclRefType.xlsx");
}
private Reference getSourceReference() {
Reference result = ReferenceFactory.newDatabase();
- result.setTitleCache("CONABIO database", true);
- VerbatimTimePeriod tp = TimePeriodParser.parseStringVerbatim("2016");
- tp.setStartMonth(5);
+ result.setTitle("CONABIO database");
+ VerbatimTimePeriod tp = TimePeriodParser.parseStringVerbatim("2021");
+ tp.setStartMonth(7);
result.setDatePublished(tp);
Institution inst = Institution.NewNamedInstance("CONABIO");
result.setInstitution(inst);
private Reference getSecReference() {
Reference result = ReferenceFactory.newDatabase();
- result.setTitle("Rubiáceas de México");
- result.setDatePublished(TimePeriodParser.parseStringVerbatim("2016"));
- Person author = Person.NewInstance();
- author.setGivenName("Helga");
- author.setFamilyName("Ochoterena Booth");
- result.setAuthorship(author);
- result.setUuid(MexicoConabioTransformer.uuidReferenceConabio);
+ result.setTitle("Flora de México");
+ result.setDatePublished(TimePeriodParser.parseStringVerbatim("2021+"));
+// Person author = Person.NewInstance();
+// author.setGivenName("Helga");
+// author.setFamilyName("Ochoterena Booth");
+// result.setAuthorship(author);
+ result.setUuid(MexicoConabioTransformer.uuidReferenceConabio2);
return result;
}
return result;
}
- /**
- * @param args
- */
public static void main(String[] args) {
- MexicoBorhidiActivator borhidi = new MexicoBorhidiActivator();
- borhidi.doImport(cdmDestination);
+// MexicoBorhidiActivator borhidi = new MexicoBorhidiActivator();
+// borhidi.doImport(cdmDestination);
MexicoConabioActivator conabio = new MexicoConabioActivator();
conabio.doImport(cdmDestination);
System.exit(0);
}
-}
+}
\ No newline at end of file
String langStr = getValueNd(record, "Lengua");
Language language = languagesMap.get(langStr);
if (language == null && langStr != null){
- logger.warn("Language not found: " + langStr);
+ addNewLanguage(state, langStr);
}
+ logger.warn("Common names for the same taxon using the same common name but differing in source are currently not yet deduplicated. Needs to be fixed for next import");
String refStr = getValue(record, "ReferenciasNombreComun");
CommonTaxonName commonName = CommonTaxonName.NewInstance(nomComunStr,
}
}
+ private Language addNewLanguage(SimpleExcelTaxonImportState<CONFIG> state, String langStr) {
+ UUID uuid = getNewLanguageUuid(langStr);
+ if (uuid != null){
+ Language newLanguage = addLanguage(state, langStr, uuid);
+ getTermService().saveOrUpdate(newLanguage);
+ logger.warn("New language added: " + langStr + "("+ uuid + ")");
+ return newLanguage;
+ }else{
+ logger.warn("Language not recognized: " + langStr);
+ return null;
+ }
+ }
+
+ private UUID getNewLanguageUuid(String langStr) {
+ if (langStr.equals("Mixteco")){return MexicoConabioTransformer.uuidMixteco;}
+ else if (langStr.equals("Náhuatl-Español")){return MexicoConabioTransformer.uuidNahuatlEspanol;}
+ else if (langStr.equals("Español-Náhuatl")){return MexicoConabioTransformer.uuidEspanolNahuatl;}
+ else if (langStr.equals("Tzotzil")){return MexicoConabioTransformer.uuidTzotzil;}
+ else if (langStr.equals("Tetzal")){return MexicoConabioTransformer.uuidTetzal;}
+ else if (langStr.equals("Tzeltal")){return MexicoConabioTransformer.uuidTzeltal;}
+ else if (langStr.equals("Mazateco")){return MexicoConabioTransformer.uuidMazateco;}
+ else if (langStr.equals("Tepehua")){return MexicoConabioTransformer.uuidTepehua;}
+
+ else if (langStr.equals("Cuicateco")){return MexicoConabioTransformer.uuidCuicateco;}
+ else if (langStr.equals("Zoque")){return MexicoConabioTransformer.uuidZoque;}
+ else if (langStr.equals("Tepehuano")){return MexicoConabioTransformer.uuidTepehuano;}
+ else if (langStr.equals("Popoloca")){return MexicoConabioTransformer.uuidPopoloca;}
+ else if (langStr.equals("Tojolabal")){return MexicoConabioTransformer.uuidTojolabal;}
+
+ else if (langStr.equals("Mayo")){return MexicoConabioTransformer.uuidMayo;}
+ else if (langStr.equals("Huichol")){return MexicoConabioTransformer.uuidHuichol;}
+ else if (langStr.equals("Cora")){return MexicoConabioTransformer.uuidCora;}
+ else if (langStr.equals("Seri")){return MexicoConabioTransformer.uuidSeri;}
+
+
+
+
+ return null;
+ }
+
private void initTaxa() {
if (taxonIdMap == null){
Set<String> existingKeys = MexicoConabioTaxonImport.taxonIdMap.keySet();
languagesVoc = this.getVocabularyService().find(MexicoConabioTransformer.uuidMexicanLanguagesVoc);
if (languagesVoc == null){
createLanguagesVoc(state);
+ }else{
+ fillLanguageMap();
}
}
}
- /**
- * @param state
- * @return
- */
+ private void fillLanguageMap() {
+ for (Language language: languagesVoc.getTerms()){
+ String label = language.getLabel();
+ languagesMap.put(label, language);
+ }
+ }
+
private void createLanguagesVoc(SimpleExcelTaxonImportState<CONFIG> state) {
URI termSourceUri = null;
String label = "Mexican States";
return;
}
- /**
- * @param state
- * @param string
- * @param uuidaguascalientes
- */
- private void addLanguage(SimpleExcelTaxonImportState<CONFIG> state, String label, UUID uuid) {
+ private Language addLanguage(SimpleExcelTaxonImportState<CONFIG> state, String label, UUID uuid) {
String abbrev = null;
Language language = Language.NewInstance(
label, label, abbrev);
language.setUuid(uuid);
languagesVoc.addTerm(language);
languagesMap.put(label, language);
+ return language;
}
- /**
- * @param state
- * @param refStr
- * @return
- */
private Reference getReference(SimpleExcelTaxonImportState<CONFIG> state, String refStr) {
- if (StringUtils.isNoneBlank(refStr)){
+ if (StringUtils.isBlank(refStr)){
return null;
}
Reference ref = state.getReference(refStr);
import eu.etaxonomy.cdm.ext.geo.GeoServiceArea;
import eu.etaxonomy.cdm.ext.geo.GeoServiceAreaAnnotatedMapping;
import eu.etaxonomy.cdm.io.common.mapping.UndefinedTransformerMethodException;
+import eu.etaxonomy.cdm.model.common.CdmBase;
import eu.etaxonomy.cdm.model.common.Language;
import eu.etaxonomy.cdm.model.description.Distribution;
import eu.etaxonomy.cdm.model.description.PresenceAbsenceTerm;
distrStatusStr, distrStatusStr, null, false);
}
if (mexicanDistributionStatus != null){
- Distribution mexicanDistribution = Distribution.NewInstance(mexico, mexicanDistributionStatus);
+ NamedArea mexicoCountry = getMexico();
+ Distribution mexicanDistribution = Distribution.NewInstance(mexicoCountry, mexicanDistributionStatus);
desc.addElement(mexicanDistribution);
String refStr = getValue(record, "ReferenciaTipoDistribucion");
Reference ref = getReference(state, refStr);
getTaxonService().save(taxon);
}
+ }
-
+ private NamedArea getMexico() {
+ if (mexico == null){
+ mexico = CdmBase.deproxy(getTermService().find(MexicoConabioTransformer.uuidMexicoCountry), NamedArea.class);
+ if (mexico == null){
+ logger.warn("Mexico country not found");
+ }
+ }
+ return mexico;
}
/**
* @return
*/
private Reference getReference(SimpleExcelTaxonImportState<CONFIG> state, String refStr) {
- if (StringUtils.isNoneBlank(refStr)){
+ if (StringUtils.isBlank(refStr)){
return null;
}
Reference ref = state.getReference(refStr);
import eu.etaxonomy.cdm.model.taxon.TaxonBase;
import eu.etaxonomy.cdm.model.taxon.TaxonRelationship;
import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;
+import eu.etaxonomy.cdm.model.term.DefinedTerm;
import eu.etaxonomy.cdm.strategy.exceptions.UnknownCdmTypeException;
import eu.etaxonomy.cdm.strategy.parser.TimePeriodParser;
"FamAceptada","GenAceptado","CategoriaTaxAceptada","NombreAceptado","AutorNombreAceptado","AutorSinAnioAceptado","AnioAceptado",
"TipoRelacion","ReferenciaSinonimia","ComentariosRevisor",
"CompareID","IdCAT_OLD","Nombre_OLD","AutorSinAnio_OLD",
- "CitaNomenclatural_OLD","ReferenceType","IsUpdated"
+ "CitaNomenclatural_OLD","ReferenceType","IsUpdated",
+
+ "Hibrido","ReferenciaNombreHibrido","AutorHibrido","EstatusHibrido",
+ "Subgenero","ReferenciaNombreSubgenero","EstatusSubgenero","AutorSubgenero",
+ "Subtribu","ReferenciaClasificacionSubtribu","AutorSubtribu","EstatusSubtribu",
+ "Subfamilia","ReferenciaClasificacionSubfamilia","AutorSubfamilia","EstatusSubfamilia",
+ "ReferenciaClasificacionTribu",
+ "Supertribu","ReferenciaClasificacionSupertribu","AutorSupertribu","EstatusSupertribu",
+
});
}
//Name
- IBotanicalName speciesName = makeName(line, record, state);
+ IBotanicalName name = makeName(line, record, state);
//sec
- String secRefStr = getValueNd(record, "ReferenciaNombre");
- Reference sec = getSecRef(state, secRefStr, line);
+ String referenciaNombre = getValueNd(record, "ReferenciaNombre");
//status
String statusStr = getValue(record, "EstatusNombre");
+ String originalInfo = null;
TaxonBase<?> taxonBase;
if ("aceptado".equals(statusStr)){
- taxonBase = Taxon.NewInstance(speciesName, sec);
+ Reference sec = getSecRef(state, referenciaNombre, line);
+ taxonBase = Taxon.NewInstance(name, sec);
}else if (statusStr.startsWith("sin")){
- taxonBase = Synonym.NewInstance(speciesName, sec);
+ String secRefStr = getValue(record, "ReferenciaSinonimia");
+
+ Reference sec = getSynSec(state, secRefStr, referenciaNombre, line);
+ taxonBase = Synonym.NewInstance(name, sec);
+ if (isNotBlank(secRefStr)){
+ originalInfo = "referenciaNombre: " + referenciaNombre;
+ }
}else{
throw new RuntimeException(line + " Status not recognized: " + statusStr);
}
//id
String idCat = getValue(record, "IdCAT");
- this.addOriginalSource(taxonBase, idCat, TAXON_NAMESPACE, state.getConfig().getSourceReference());
+ this.addOriginalSource(taxonBase, idCat, TAXON_NAMESPACE, state.getConfig().getSourceReference(), originalInfo);
+ name.addIdentifier(idCat, getConabioIdIdentifierType(state));
+
+// checkSame(record, "EstatusHibrido", statusStr, line);
+// checkSame(record, "AutorHibrido", "AutorNombre", line);
+// checkSame(record, "ReferenciaNombreHibrido", "ReferenciaNombre", line);
+// checkSame(record, "Hibrido", "AutorNombre", line);
//save
getTaxonService().save(taxonBase);
taxonIdMap.put(idCat, taxonBase);
+ }
+ private DefinedTerm getConabioIdIdentifierType(SimpleExcelTaxonImportState<CONFIG> state) {
+ DefinedTerm conabioIdIdentifierType = getIdentiferType(state, MexicoConabioTransformer.uuidConabioIdIdentifierType, "Conabio name identifier", "Conabio name identifier", "CONABIO ID", null);
+ return conabioIdIdentifierType;
}
+ private void checkSame(Map<String, String> record, String key, String compareValue, String line) {
+ String value = getValue(record, key);
+ if (value != null && !value.equals(compareValue)){
+ logger.warn(line+ ": Value differs for "+ key +": " + value + "<->" + compareValue );
+ }
+ }
+ private Reference getSynSec(SimpleExcelTaxonImportState<CONFIG> state, String secRefStr,
+ String referenciaNombre, String line) {
+ if (isBlank(secRefStr)){
+ secRefStr = referenciaNombre;
+ }
+ if (isNotBlank(secRefStr)){
+ Reference result = state.getReference(secRefStr);
+ if (result == null){
+ result = ReferenceFactory.newBook();
+ result.setTitleCache(secRefStr, true);
+ state.putReference(secRefStr, result);
+ }
+ return result;
+ }else{
+ return null;
+ }
+ }
/**
* @param state
Rank rank = null;
try {
rank = state.getTransformer().getRankByKey(rankStr);
- if (Rank.SUBSPECIES().equals(rank) || Rank.VARIETY().equals(rank)){
+ if (Rank.SUBSPECIES().equals(rank) || Rank.VARIETY().equals(rank) || Rank.FORM().equals(rank) || Rank.RACE().equals(rank)){
int i = nameStr.lastIndexOf(" ");
nameStr = nameStr.substring(0, i) + " " + rank.getAbbreviation() + nameStr.substring(i);
}
this.addOriginalSource(result, idCat, TAXON_NAMESPACE + "_Name", state.getConfig().getSourceReference());
+ if(result.getNomenclaturalReference()!=null && result.getNomenclaturalReference().getTitleCache().equals("null")){
+ logger.warn("null");
+ }
+
return result;
}
private String getRefNameStr(String nomRefStr, String refTypeStr, String fullNameStr) {
String refNameStr = fullNameStr;
ReferenceType refType = refTypeByRefTypeStr(refTypeStr);
- if (refType == ReferenceType.Article){
+ if (nomRefStr == null){
+ //do nothing
+ }else if (refType == ReferenceType.Article){
refNameStr = fullNameStr + " in " + nomRefStr;
}else if (refType == ReferenceType.Book){
refNameStr = fullNameStr + ", " + nomRefStr;
String idCat = getValue(record, "IdCAT");
TaxonBase<?> taxonBase = taxonIdMap.get(idCat);
Taxon parent;
- if ("aceptado".equals(statusStr)){
+ if(statusStr == null){
+ logger.warn("No statusStr in line " +line);
+ }else if ("aceptado".equals(statusStr)){
parent = (Taxon)taxonIdMap.get(parentStr);
if (parent == null){
logger.warn(line + "Parent is missing: "+ parentStr);
Taxon taxon = (Taxon)taxonBase;
Reference relRef = null; //TODO
classification.addParentChild(parent, taxon, relRef, null);
- makeConceptRelation(line, taxon.getName());
-
+// makeConceptRelation(line, taxon.getName());
}
}else if (statusStr.startsWith("sin")){
parent = (Taxon)taxonIdMap.get(relStr);
}else{
Synonym synonym = (Synonym)taxonBase;
parent.addSynonym(synonym, SynonymType.SYNONYM_OF());
- makeConceptRelation(line, synonym.getName());
+// makeConceptRelation(line, synonym.getName());
}
+ }else{
+ logger.warn("Unhandled statusStr in line " + line);
}
}
}
}
-
-
- /**
- * @return
- */
private Classification getClassification(SimpleExcelTaxonImportState<CONFIG> state) {
if (classification == null){
MexicoConabioImportConfigurator config = state.getConfig();
- classification = Classification.NewInstance(config.getClassificationName());
- classification.setUuid(config.getClassificationUuid());
- classification.setReference(config.getSecReference());
- getClassificationService().save(classification);
+ classification = getClassificationService().find(config.getClassificationUuid());
+ if (classification == null){
+ classification = Classification.NewInstance(config.getClassificationName());
+ classification.setUuid(config.getClassificationUuid());
+ classification.setReference(config.getSecReference());
+ getClassificationService().save(classification);
+ }
}
return classification;
}
private static final Logger logger = Logger.getLogger(MexicoConabioTransformer.class);
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");
public static final UUID uuidNomRefExtension = UUID.fromString("0a7e2f5f-c62d-43e1-874a-07cb1dbb9fa0");
public static final UUID uuidTotonaco = UUID.fromString("2eae8d72-a45c-48be-b9a4-aaf96d21df0a");
public static final UUID uuidTarasco = UUID.fromString("cf597916-0422-495f-bf0b-ea0841e32a52");
+ public static final UUID uuidMixteco = UUID.fromString("a1e4ad97-9ae0-43a7-993b-8ed9df1837b9");
+ public static final UUID uuidNahuatlEspanol = UUID.fromString("e3014862-bdfc-4f3b-a3c9-f453c0997de1");
+ public static final UUID uuidEspanolNahuatl = UUID.fromString("6c70e207-ccb7-420e-9d4b-86013b5ac105");
+ public static final UUID uuidTzotzil = UUID.fromString("f2c46f9b-9580-4342-b35c-1a356b832424");
+ public static final UUID uuidTetzal = UUID.fromString("99f0a31c-d0ef-439f-bf16-be7d2f40a5f3");
+ public static final UUID uuidTzeltal = UUID.fromString("18c3db8d-aae6-4da8-a1a7-2034454e4631");
+ public static final UUID uuidMazateco = UUID.fromString("150b5f4b-afcd-435a-8c36-82398162bb55");
+ public static final UUID uuidTepehua = UUID.fromString("8b17f444-8581-4dd7-8fbb-099a8e4f2a5b");
+
+ public static final UUID uuidCuicateco = UUID.fromString("5bd309ac-3677-4742-8c0a-18e552f9334f");
+ public static final UUID uuidZoque = UUID.fromString("86e84d38-e3ce-4b8e-9e4c-23fcf6aaf575");
+ public static final UUID uuidTepehuano = UUID.fromString("f404d3a5-759c-424f-935b-5be2a9d4da77");
+ public static final UUID uuidPopoloca = UUID.fromString("458eb628-9721-4bd4-ab7d-331dc2efdc13");
+ public static final UUID uuidTojolabal = UUID.fromString("9ec79d06-0501-41c9-8f56-698bb03a5958");
+
+ public static final UUID uuidMayo = UUID.fromString("19a3d783-9910-4d8f-a755-fc74130b14e3");
+ public static final UUID uuidHuichol = UUID.fromString("35898e28-bb27-4254-b6e3-372fb53cb60b");
+ public static final UUID uuidCora = UUID.fromString("f48c1852-6875-4db2-b104-1b99ca6556ab");
+ public static final UUID uuidSeri = UUID.fromString("6d153f30-daed-4225-bb41-4367f78a608c");
+
@Override
public Rank getRankByKey(String key) throws UndefinedTransformerMethodException {
}else if (key.equals("subclase")){return Rank.SUBCLASS();
}else if (key.equals("clase")){return Rank.CLASS();
}else if (key.equals("familia")){return Rank.FAMILY();
+ }else if (key.equals("subfamilia")){return Rank.SUBFAMILY();
+
}else if (key.equals("tribu")){return Rank.TRIBE();
+ }else if (key.equals("subtribu")){return Rank.SUBTRIBE();
}else if (key.equals("superorden")){return Rank.SUPERORDER();
}else if (key.equals("división")){return Rank.DIVISION();
}else if (key.equals("género")){return Rank.GENUS();
+ }else if (key.equals("subgénero")){return Rank.SUBGENUS();
}else if (key.equals("especie")){return Rank.SPECIES();
}else if (key.equals("subespecie")){return Rank.SUBSPECIES();
}else if (key.equals("variedad")){return Rank.VARIETY();
+ }else if (key.equals("forma")){return Rank.FORM();
+ }else if (key.equals("raza")){return Rank.RACE();
}else{
logger.warn("Rank not defined: " + key);
return null;
}
}
-
@Override
public PresenceAbsenceTerm getPresenceTermByKey(String key) throws UndefinedTransformerMethodException {
if (StringUtils.isBlank(key)){
import eu.etaxonomy.cdm.io.excel.common.ExcelImportBase;
import eu.etaxonomy.cdm.io.excel.common.ExcelImportConfiguratorBase;
import eu.etaxonomy.cdm.io.excel.common.ExcelRowBase;
+import eu.etaxonomy.cdm.model.agent.AgentBase;
import eu.etaxonomy.cdm.model.agent.Person;
import eu.etaxonomy.cdm.model.agent.Team;
import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase;
private void initAgentMap(SimpleExcelTaxonImportState<CONFIG> state) {
if (!agentMapIsInitialized){
List<String> propertyPaths = Arrays.asList("");
- List<TeamOrPersonBase> existingAgents = this.getAgentService().list(null, null, null, null, propertyPaths);
- for (TeamOrPersonBase agent : existingAgents){
- state.putAgentBase(agent.getTitleCache(), agent);
+ List<AgentBase<?>> existingAgents = this.getAgentService().list(null, null, null, null, propertyPaths);
+ for (AgentBase<?> agent : existingAgents){
+ if (agent.isInstanceOf(TeamOrPersonBase.class)){
+ state.putAgentBase(agent.getTitleCache(), (TeamOrPersonBase)agent);
+ }
}
agentMapIsInitialized = true;
}
BGBM BDI Projects / cdmlib-apps.git / commitdiff