/**\r
- * \r
- */\r
+* Copyright (C) 2009 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.tcsxml.in;\r
\r
+import java.io.InputStream;\r
+import java.util.ArrayList;\r
import java.util.HashSet;\r
import java.util.List;\r
import java.util.Map;\r
import org.apache.log4j.Logger;\r
import org.jdom.Element;\r
import org.jdom.Namespace;\r
+import org.springframework.beans.factory.annotation.Autowired;\r
import org.springframework.stereotype.Component;\r
\r
+import eu.etaxonomy.cdm.common.CdmUtils;\r
import eu.etaxonomy.cdm.common.ResultWrapper;\r
import eu.etaxonomy.cdm.common.XmlHelp;\r
+import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;\r
import eu.etaxonomy.cdm.io.common.ICdmIO;\r
-import eu.etaxonomy.cdm.io.common.IImportConfigurator;\r
import eu.etaxonomy.cdm.io.common.MapWrapper;\r
+import eu.etaxonomy.cdm.io.tcsrdf.TcsRdfImportConfigurator;\r
+import eu.etaxonomy.cdm.io.tcsrdf.TcsRdfTaxonNameImport;\r
import eu.etaxonomy.cdm.io.tcsxml.TcsXmlTransformer;\r
import eu.etaxonomy.cdm.model.common.CdmBase;\r
+import eu.etaxonomy.cdm.model.common.OriginalSourceType;\r
import eu.etaxonomy.cdm.model.common.RelationshipTermBase;\r
-import eu.etaxonomy.cdm.model.name.NonViralName;\r
-import eu.etaxonomy.cdm.model.name.TaxonNameBase;\r
-import eu.etaxonomy.cdm.model.reference.ReferenceBase;\r
+import eu.etaxonomy.cdm.model.description.CommonTaxonName;\r
+import eu.etaxonomy.cdm.model.description.TaxonDescription;\r
+import eu.etaxonomy.cdm.model.name.TaxonName;\r
+import eu.etaxonomy.cdm.model.name.TaxonNameFactory;\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.SynonymType;\r
import eu.etaxonomy.cdm.model.taxon.Taxon;\r
import eu.etaxonomy.cdm.model.taxon.TaxonBase;\r
+import eu.etaxonomy.cdm.model.taxon.TaxonNode;\r
import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;\r
import eu.etaxonomy.cdm.strategy.exceptions.UnknownCdmTypeException;\r
\r
*\r
*/\r
@Component\r
-public class TcsXmlTaxonRelationsImport extends TcsXmlImportBase implements ICdmIO<IImportConfigurator> {\r
- private static final Logger logger = Logger.getLogger(TcsXmlTaxonRelationsImport.class);\r
+public class TcsXmlTaxonRelationsImport extends TcsXmlImportBase implements ICdmIO<TcsXmlImportState> {\r
+ private static final long serialVersionUID = 6632990505515905663L;\r
+\r
+ private static final Logger logger = Logger.getLogger(TcsXmlTaxonRelationsImport.class);\r
\r
private static int modCount = 30000;\r
\r
+ @Autowired\r
+ private TcsRdfTaxonNameImport rdfNameImport;\r
+ private TcsRdfImportConfigurator rdfConfig = TcsRdfImportConfigurator.NewInstance(null, null);\r
+\r
public TcsXmlTaxonRelationsImport(){\r
super();\r
+\r
}\r
- \r
+\r
@Override\r
- public boolean doCheck(IImportConfigurator config){\r
+ public boolean doCheck(TcsXmlImportState state){\r
boolean result = true;\r
logger.warn("Checking for TaxonRelations not yet implemented");\r
logger.warn("Creation of homotypic relations is still problematic");\r
//result &= checkArticlesWithoutJournal(bmiConfig);\r
//result &= checkPartOfJournal(bmiConfig);\r
- \r
+\r
return result;\r
}\r
- \r
+\r
@Override\r
- public boolean doInvoke(TcsXmlImportState state){ \r
- \r
- \r
+ public void doInvoke(TcsXmlImportState state){\r
+\r
+\r
logger.info("start make taxon relations ...");\r
MapWrapper<TaxonBase> taxonMap = (MapWrapper<TaxonBase>)state.getStore(ICdmIO.TAXON_STORE);\r
- MapWrapper<TaxonNameBase<?,?>> taxonNameMap = (MapWrapper<TaxonNameBase<?,?>>)state.getStore(ICdmIO.TAXONNAME_STORE);\r
- MapWrapper<ReferenceBase> referenceMap = (MapWrapper<ReferenceBase>)state.getStore(ICdmIO.REFERENCE_STORE);\r
+ MapWrapper<TaxonName> taxonNameMap = (MapWrapper<TaxonName>)state.getStore(ICdmIO.TAXONNAME_STORE);\r
+ MapWrapper<Reference> referenceMap = (MapWrapper<Reference>)state.getStore(ICdmIO.REFERENCE_STORE);\r
\r
Set<TaxonBase> taxonStore = new HashSet<TaxonBase>();\r
\r
ResultWrapper<Boolean> success = ResultWrapper.NewInstance(true);\r
String childName;\r
boolean obligatory;\r
- String idNamespace = "TaxonRelation";\r
+ String idNamespace = "TaxonRelationDTO";\r
\r
TcsXmlImportConfigurator config = state.getConfig();\r
Element elDataSet = super.getDataSetElement(config);\r
Namespace tcsNamespace = config.getTcsXmlNamespace();\r
- \r
+\r
childName = "TaxonConcepts";\r
obligatory = false;\r
Element elTaxonConcepts = XmlHelp.getSingleChildElement(success, elDataSet, childName, tcsNamespace, obligatory);\r
- \r
+\r
childName = "TaxonConcept";\r
- List<Element> elTaxonConceptList = elTaxonConcepts.getChildren(childName, tcsNamespace);\r
- \r
+ List<Element> elTaxonConceptList = elTaxonConcepts == null ? new ArrayList<Element>() : elTaxonConcepts.getChildren(childName, tcsNamespace);\r
+\r
int i = 0;\r
int taxonRelCount = 0;\r
- \r
+\r
//for each taxonConcept\r
+ logger.info("NUmber of taxon concepts: " + elTaxonConceptList.size());\r
for (Element elTaxonConcept : elTaxonConceptList){\r
if ((i++ % modCount) == 0){ logger.info("Taxa handled: " + (i-1));}\r
- taxonRelCount += makeTaxonConcept(config, taxonMap, taxonStore, elTaxonConcept, tcsNamespace, success); \r
+ taxonRelCount += makeTaxonConcept(state, taxonMap, taxonStore, elTaxonConcept, tcsNamespace, success);\r
}//elTaxonConcept\r
- \r
+ logger.info("Taxa handled: " + taxonStore.size());\r
//TaxonRelationshipAssertions\r
- taxonRelCount += makeTaxonRelationshipAssertion(config, taxonMap, referenceMap, taxonStore, elDataSet, tcsNamespace, success); \r
- \r
+ taxonRelCount += makeTaxonRelationshipAssertion(state, taxonMap, referenceMap, taxonStore, elDataSet, tcsNamespace, success);\r
+\r
logger.info("Taxa to save: " + taxonStore.size());\r
- getTaxonService().saveTaxonAll(taxonStore);\r
- \r
+ getTaxonService().save(taxonStore);\r
+\r
+ //do basionym relationships\r
+ childName = "TaxonNames";\r
+ obligatory = false;\r
+ Element elTaxonNames = XmlHelp.getSingleChildElement(success, elDataSet, childName, tcsNamespace, obligatory);\r
+\r
+ childName = "TaxonName";\r
+ List<Element> elTaxonNameList = elTaxonNames == null ? new ArrayList<Element>() : elTaxonNames.getChildren(childName, tcsNamespace);\r
+\r
+ logger.info("NUmber of taxon concepts: " + elTaxonNameList.size());\r
+ for (Element elTaxonName : elTaxonNameList){\r
+ if ((i++ % modCount) == 0){ logger.info("Taxa handled: " + (i-1));}\r
+ taxonRelCount += makeBasionymRelations(state, taxonMap, taxonNameMap, taxonStore, elTaxonName, tcsNamespace, success);\r
+ }//elTaxonConcept\r
+ logger.info("Taxa handled: " + taxonStore.size());\r
+\r
+\r
+ taxonStore = null;\r
logger.info("end make taxon relations ...");\r
- return success.getValue();\r
+ if (!success.getValue()){\r
+ state.setUnsuccessfull();\r
+ }\r
+ return;\r
}\r
- \r
- private int makeTaxonConcept(TcsXmlImportConfigurator tcsConfig, MapWrapper<TaxonBase> taxonMap, Set<TaxonBase> taxonStore, Element elTaxonConcept, Namespace tcsNamespace, ResultWrapper<Boolean> success){\r
+\r
+ private int makeBasionymRelations(TcsXmlImportState state,\r
+ MapWrapper<TaxonBase> taxonMap, MapWrapper<TaxonName> taxonNameMap, Set<TaxonBase> taxonStore,\r
+ Element elTaxonName, Namespace tcsNamespace,\r
+ ResultWrapper<Boolean> success) {\r
+\r
+ /*\r
+ * <tcs:Basionym>\r
+ <tcs:RelatedName ref="urn:lsid:ipni.org:names:50000063-1">Caryophyllaceae</tcs:RelatedName>\r
+ </tcs:Basionym>\r
+ */\r
+\r
+\r
+ String childName = "Basionym";\r
+ boolean obligatory = false;\r
+ Element elBasionymRelationships = XmlHelp.getSingleChildElement(success, elTaxonName, childName, tcsNamespace, obligatory);\r
+ if (elBasionymRelationships != null){\r
+ childName = "RelatedName";\r
+ obligatory = false;\r
+ Element elBasionym = XmlHelp.getSingleChildElement(success, elBasionymRelationships, childName, tcsNamespace, obligatory);\r
+\r
+ String id = elTaxonName.getAttributeValue("id");\r
+ TaxonName name = taxonNameMap.get(removeVersionOfRef(id));\r
+\r
+ TaxonBase taxonBase = (TaxonBase)name.getTaxonBases().iterator().next();\r
+\r
+ String ref = elBasionym.getAttributeValue("ref");\r
+ TaxonName basionymName = taxonNameMap.get(removeVersionOfRef(ref));\r
+\r
+ if (basionymName != null){\r
+ basionymName = HibernateProxyHelper.deproxy(basionymName, TaxonName.class);\r
+ TaxonBase basionym;\r
+ if (basionymName.getTaxonBases().isEmpty()){\r
+ basionym = Synonym.NewInstance(basionymName, null);\r
+ }else{\r
+ basionym = (TaxonBase)basionymName.getTaxonBases().iterator().next();\r
+ }\r
+ //Synonym basionymSyn;\r
+ if (basionym instanceof Taxon){\r
+\r
+ if (!(taxonBase instanceof Synonym)){\r
+ logger.debug("The taxon " + basionymName.getTitleCache() + " is used in a concept and can not be a synonym " + name.getTitleCache() + "but will be added as basionym for the homotypical group");\r
+ name.addBasionym(basionymName);\r
+ //basionymName.getHomotypicalGroup().addTypifiedName(name);\r
+ } else if (taxonBase instanceof Synonym){\r
+ Synonym synonym = (Synonym) taxonBase;\r
+ ((Taxon)basionym).addSynonym(synonym, SynonymType.HOMOTYPIC_SYNONYM_OF());\r
+ basionym.getHomotypicGroup().setGroupBasionym(basionymName);\r
+ taxonStore.add(basionym);\r
+ }\r
+ }else{\r
+ if (taxonBase instanceof Taxon){\r
+ Synonym synonym = (Synonym) basionym;\r
+ ((Taxon)taxonBase).addSynonym(synonym, SynonymType.HOMOTYPIC_SYNONYM_OF());\r
+ taxonBase.getHomotypicGroup().setGroupBasionym(basionymName);\r
+ taxonStore.add(taxonBase);\r
+ } else{\r
+ Taxon acc = ((Synonym)taxonBase).getAcceptedTaxon();\r
+ if (acc != null){\r
+ acc.addHomotypicSynonym((Synonym)basionym);\r
+ basionymName.getHomotypicalGroup().setGroupBasionym(basionymName);\r
+ }\r
+ }\r
+ }\r
+\r
+\r
+ } else{\r
+ basionymName = TaxonNameFactory.NewNonViralInstance(name.getRank());\r
+ childName = "RelatedName";\r
+ obligatory = true;\r
+ Element elName = XmlHelp.getSingleChildElement(success, elBasionym, childName, tcsNamespace, obligatory);\r
+ String strName = (elName == null)? "" : elName.getTextNormalize();\r
+ basionymName.setTitleCache(strName, false);\r
+ Synonym basionymSyn = Synonym.NewInstance(basionymName, unknownSec());\r
+ if (taxonBase instanceof Taxon){\r
+ Taxon taxon = (Taxon)taxonBase;\r
+ taxon.addSynonym(basionymSyn, SynonymType.HOMOTYPIC_SYNONYM_OF());\r
+ taxon.getHomotypicGroup().setGroupBasionym(basionymName);\r
+ taxonStore.add(taxon);\r
+ } else{\r
+ Synonym syn = (Synonym) taxonBase;\r
+ if (syn.getAcceptedTaxon() != null){\r
+ Taxon accTaxon = syn.getAcceptedTaxon();\r
+ accTaxon.addSynonym(basionymSyn, SynonymType.HOMOTYPIC_SYNONYM_OF());\r
+ accTaxon.getHomotypicGroup().setGroupBasionym(basionymName);\r
+ taxonStore.add(accTaxon);\r
+ }\r
+ }\r
+ }\r
+ }\r
+ return 1;\r
+ }\r
+\r
+ private int makeTaxonConcept(TcsXmlImportState state, MapWrapper<TaxonBase> taxonMap, Set<TaxonBase> taxonStore, Element elTaxonConcept, Namespace tcsNamespace, ResultWrapper<Boolean> success){\r
int taxonRelCount = 0;\r
- \r
+\r
String childName = "TaxonRelationships";\r
boolean obligatory = false;\r
Element elTaxonRelationships = XmlHelp.getSingleChildElement(success, elTaxonConcept, childName, tcsNamespace, obligatory);\r
- \r
+\r
if (elTaxonRelationships != null){\r
//Relationships\r
String tcsElementName = "TaxonRelationship";\r
List<Element> elTaxonRelationshipList = elTaxonRelationships.getChildren(tcsElementName, tcsNamespace);\r
-\r
+ logger.info("Number of taxonrelationships: " + elTaxonRelationshipList.size());\r
for (Element elTaxonRelationship: elTaxonRelationshipList){\r
+\r
taxonRelCount++;\r
logger.debug("TaxonRelationship "+ taxonRelCount);\r
- \r
+\r
String strId = elTaxonConcept.getAttributeValue("id");\r
//TODO\r
// String strConceptType = elTaxonConcept.getAttributeValue("type"); //original, revision, incomplete, aggregate, nominal\r
// String strPrimary = elTaxonConcept.getAttributeValue("primary"); //If primary='true' the concept is the first level response to a query. If 'false' the concept may be a secondary concept linked directly or indirectly to the definition of a primary concept.\r
// String strForm = elTaxonConcept.getAttributeValue("form"); //anamorph, teleomorph, hybrid\r
- \r
- TaxonBase fromTaxon = taxonMap.get(strId);\r
- makeRelationshipType(tcsConfig, elTaxonRelationship, taxonMap, taxonStore, fromTaxon, success);\r
- \r
+\r
+ TaxonBase fromTaxon = taxonMap.get(removeVersionOfRef(strId));\r
+ makeRelationshipType(state, elTaxonRelationship, taxonMap, taxonStore, fromTaxon, success);\r
+\r
if (fromTaxon instanceof Taxon){\r
makeHomotypicSynonymRelations((Taxon)fromTaxon);\r
}\r
}\r
\r
private int makeTaxonRelationshipAssertion(\r
- TcsXmlImportConfigurator tcsConfig, \r
+ TcsXmlImportState state,\r
MapWrapper<TaxonBase> taxonMap,\r
- MapWrapper<ReferenceBase> referenceMap,\r
- Set<TaxonBase> taxonStore, \r
- Element elDataSet, \r
- Namespace tcsNamespace, \r
+ MapWrapper<Reference> referenceMap,\r
+ Set<TaxonBase> taxonStore,\r
+ Element elDataSet,\r
+ Namespace tcsNamespace,\r
ResultWrapper<Boolean> success){\r
- \r
+\r
int i = 0;\r
String childName = "TaxonRelationshipAssertions";\r
boolean obligatory = false;\r
if(elTaxonRelationshipAssertions == null){\r
return 0;\r
}\r
- \r
+\r
childName = "TaxonRelationshipAssertion";\r
List<Element> elTaxonRelationshipAssertionList = elTaxonRelationshipAssertions.getChildren(childName, tcsNamespace);\r
//for each taxon relationship assertion\r
if ((i++ % modCount) == 0){ logger.info("TaxonRelationshipAssertions handled: " + (i-1));}\r
String strId = elTaxonRelationshipAssertion.getAttributeValue("id");\r
//TODO id\r
- \r
+\r
childName = "AccordingTo";\r
obligatory = true;\r
Element elAccordingTo = XmlHelp.getSingleChildElement(success, elTaxonRelationshipAssertion, childName, tcsNamespace, obligatory);\r
- ReferenceBase ref = makeAccordingTo(elAccordingTo, referenceMap, success);\r
- \r
+ Reference ref = makeAccordingTo(elAccordingTo, referenceMap, success);\r
+\r
childName = "FromTaxonConcept";\r
obligatory = true;\r
Element elFromTaxonConcept = XmlHelp.getSingleChildElement(success, elTaxonRelationshipAssertion, childName, tcsNamespace, obligatory);\r
Class<? extends TaxonBase> clazz = Taxon.class;\r
//TODO if synonym\r
TaxonBase fromTaxon = makeReferenceType(elFromTaxonConcept, clazz, taxonMap, success);\r
- \r
- makeRelationshipType(tcsConfig, elTaxonRelationshipAssertion, taxonMap, taxonStore, fromTaxon, success);\r
+\r
+ makeRelationshipType(state, elTaxonRelationshipAssertion, taxonMap, taxonStore, fromTaxon, success);\r
}//elTaxonRelationshipAssertion\r
- \r
+\r
return i;\r
}\r
- \r
- \r
+\r
+\r
/**\r
* Handles the TCS RelationshipType element.\r
* @param tcsConfig\r
* @param success\r
*/\r
private void makeRelationshipType(\r
- TcsXmlImportConfigurator tcsConfig\r
- , Element elRelationship \r
+ TcsXmlImportState state\r
+ , Element elRelationship\r
, MapWrapper<TaxonBase> taxonMap\r
, Set<TaxonBase> taxonStore\r
, TaxonBase fromTaxon\r
, ResultWrapper<Boolean> success\r
){\r
- \r
+\r
if (elRelationship == null){\r
success.setValue(false);\r
}\r
String strRelType = elRelationship.getAttributeValue("type");\r
- \r
- \r
+\r
+\r
try {\r
ResultWrapper<Boolean> isInverse = new ResultWrapper<Boolean>();\r
isInverse.setValue(false);\r
- RelationshipTermBase<?> relType = TcsXmlTransformer.tcsRelationshipType2Relationship(strRelType, isInverse);\r
- \r
- //toTaxon (should be part of relationshipType)\r
- boolean isSynonym = (relType instanceof SynonymRelationshipType);\r
- TaxonBase toTaxon = getToTaxon(elRelationship, taxonMap, isSynonym, success);\r
- \r
- if (toTaxon != null && fromTaxon != null){\r
- //exchange taxa if relationship is inverse\r
- if (isInverse.getValue() == true ){\r
- TaxonBase tmp = toTaxon;\r
- toTaxon = fromTaxon;\r
- fromTaxon = tmp;\r
- }\r
- \r
- //Create relationship\r
- if (! (toTaxon instanceof Taxon)){\r
- logger.warn("TaxonBase toTaxon is not of Type 'Taxon'. Relationship is not added.");\r
- success.setValue(false);\r
- }else{\r
- Taxon taxonTo = (Taxon)toTaxon;\r
- ReferenceBase citation = null;\r
- String microReference = null;\r
- if (relType instanceof SynonymRelationshipType){\r
- SynonymRelationshipType synRelType = (SynonymRelationshipType)relType;\r
- if (! (fromTaxon instanceof Synonym )){\r
- logger.warn("TaxonBase fromTaxon is not of Type 'Synonym'. Relationship is not added.");\r
- success.setValue(false);\r
- }else{\r
- Synonym synonym = (Synonym)fromTaxon;\r
- TaxonNameBase<?,?> synName = synonym.getName();\r
- TaxonNameBase<?,?> accName = taxonTo.getName();\r
- if (synName != null && accName != null && synName.isHomotypic(accName)\r
- && ( synRelType.equals(SynonymRelationshipType.SYNONYM_OF()))){\r
- synRelType = SynonymRelationshipType.HOMOTYPIC_SYNONYM_OF(); \r
- }\r
- if (! relationExists(taxonTo, synonym, synRelType)){\r
- taxonTo.addSynonym(synonym, synRelType, citation, microReference); \r
- }else{\r
- //TODO citation, microReference\r
- //TODO different synRelTypes -> warning\r
+ if ("has vernacular".equalsIgnoreCase(strRelType)){\r
+ handleVernacular(success, state, elRelationship, fromTaxon);\r
+ }else{\r
+ RelationshipTermBase<?> relType = TcsXmlTransformer.tcsRelationshipType2Relationship(strRelType, isInverse);\r
+\r
+ //toTaxon (should be part of relationshipType)\r
+ boolean isSynonym = (relType instanceof SynonymType);\r
+ TaxonBase toTaxon = getToTaxon(elRelationship, taxonMap, state.getMissingConceptLSIDs(), isSynonym, success, state);\r
+\r
+ if (toTaxon != null && fromTaxon != null){\r
+ //exchange taxa if relationship is inverse\r
+ if (isInverse.getValue() == true ){\r
+ TaxonBase tmp = toTaxon;\r
+ toTaxon = fromTaxon;\r
+ fromTaxon = tmp;\r
+ }\r
+\r
+ //Create relationship\r
+ if (! (toTaxon instanceof Taxon)){\r
+ logger.warn("TaxonBase toTaxon is not of Type 'Taxon'. Relationship is not added.");\r
+ success.setValue(false);\r
+ }else{\r
+ Taxon taxonTo = (Taxon)toTaxon;\r
+ if (relType instanceof SynonymType){\r
+ SynonymType synRelType = (SynonymType)relType;\r
+ if (! (fromTaxon instanceof Synonym )){\r
+ logger.warn("TaxonBase fromTaxon is not of Type 'Synonym'. Relationship is not added.");\r
success.setValue(false);\r
+ }else{\r
+ Synonym synonym = (Synonym)fromTaxon;\r
+ TaxonName synName = synonym.getName();\r
+ TaxonName accName = taxonTo.getName();\r
+ if (synName != null && accName != null && synName.isHomotypic(accName)\r
+ && ( synRelType.equals(SynonymType.SYNONYM_OF()))){\r
+ synRelType = SynonymType.HOMOTYPIC_SYNONYM_OF();\r
+ }\r
+ if (! relationExists(taxonTo, synonym, synRelType)){\r
+ taxonTo.addSynonym(synonym, synRelType);\r
+ }else{\r
+ //TODO citation, microReference\r
+ //TODO different synRelTypes -> warning\r
+ success.setValue(false);\r
+ }\r
}\r
- }\r
- }else if (relType instanceof TaxonRelationshipType){\r
- TaxonRelationshipType taxRelType = (TaxonRelationshipType)relType;\r
- if (! (fromTaxon instanceof Taxon )){\r
- logger.warn("TaxonBase fromTaxon " + /*strTaxonAbout +*/ "is not of Type 'Taxon'. Relationship is not added.");\r
- success.setValue(false);\r
+ }else if (relType instanceof TaxonRelationshipType){\r
+ Reference citation = null;\r
+ String microReference = null;\r
+ makeTaxonRelationship(state, (TaxonRelationshipType)relType, fromTaxon, taxonTo, citation, microReference, success);\r
}else{\r
- Taxon taxonFrom = (Taxon)fromTaxon;\r
- taxonFrom.addTaxonRelation(taxonTo, taxRelType, citation, microReference);\r
+ logger.warn("Unknown Relationshiptype");\r
+ success.setValue(false);\r
}\r
- }else{\r
- logger.warn("Unknown Relationshiptype");\r
- success.setValue(false);\r
+ taxonStore.add(toTaxon);\r
}\r
- taxonStore.add(toTaxon);\r
- }\r
- }else{\r
- if (toTaxon == null){\r
- logger.warn("toTaxon (" + /*strToTaxon + */ ") could not be found in taxonMap. Relationship of type " + strRelType + " was not added to CDM");\r
- }\r
- if (fromTaxon == null){\r
- logger.warn("fromTaxon (" + /*strTaxonAbout + */") could not be found in taxonMap. Relationship was not added to CDM");\r
+ }else{\r
+ if (toTaxon == null){\r
+ // logger.warn("toTaxon (" + /*strToTaxon + */ ") could not be found in taxonMap. Relationship of type " + strRelType + " was not added to CDM");\r
+ }\r
+ if (fromTaxon == null){\r
+ // logger.warn("fromTaxon (" + /*strTaxonAbout + */") could not be found in taxonMap. Relationship was not added to CDM");\r
+ }\r
+ success.setValue(false);\r
}\r
- success.setValue(false);\r
}\r
- \r
} catch (UnknownCdmTypeException e) {\r
//TODO\r
logger.warn("relationshipType " + strRelType + " not yet implemented");\r
}\r
return;\r
}\r
- \r
- private TaxonBase getToTaxon(Element elTaxonRelationship, MapWrapper<TaxonBase> map, boolean isSynonym, ResultWrapper<Boolean> success){\r
+\r
+ private void handleVernacular(ResultWrapper<Boolean> success, TcsXmlImportState state, Element elRelationship, TaxonBase taxonBase) {\r
+ if (! taxonBase.isInstanceOf(Taxon.class)){\r
+ logger.warn("From Taxon is not of type Taxon but of type " + taxonBase.getClass().getSimpleName());\r
+ success.setValue(false);\r
+ return;\r
+ }else{\r
+ Taxon taxon = CdmBase.deproxy(taxonBase, Taxon.class);\r
+ Map<String, CommonTaxonName> commonNameMap = state.getCommonNameMap();\r
+ CommonTaxonName commonTaxonName = getCommonName(elRelationship, commonNameMap, success);\r
+ TaxonDescription description = getDescription(taxon);\r
+ description.addElement(commonTaxonName);\r
+ }\r
+ }\r
+\r
+ private TaxonDescription getDescription(Taxon taxon) {\r
+ if (taxon.getDescriptions().isEmpty()){\r
+ return TaxonDescription.NewInstance(taxon);\r
+ }else{\r
+ //TODO only if the description represents this TCS file\r
+ return taxon.getDescriptions().iterator().next();\r
+ }\r
+ }\r
+\r
+ private CommonTaxonName getCommonName(Element elTaxonRelationship, Map<String, CommonTaxonName> commonNameMap, ResultWrapper<Boolean> success){\r
+ CommonTaxonName result = null;\r
+ if (elTaxonRelationship == null || commonNameMap == null){\r
+ success.setValue(false);\r
+ }else{\r
+ String childName = "ToTaxonConcept";\r
+ boolean obligatory = true;\r
+ Element elToTaxonConcept = XmlHelp.getSingleChildElement(success, elTaxonRelationship, childName, elTaxonRelationship.getNamespace(), obligatory);\r
+\r
+ String linkType = elToTaxonConcept.getAttributeValue("linkType");\r
+ if (linkType == null || linkType.equals("local")){\r
+ String ref = elToTaxonConcept.getAttributeValue("ref");\r
+ if (ref != null){\r
+ result = commonNameMap.get(ref);\r
+ }else{\r
+ logger.warn("Non ref not yet implemented for vernacular name relationship");\r
+ }\r
+ }else{\r
+ logger.warn("External link types for vernacular name not yet implemented");\r
+ }\r
+ }\r
+ return result;\r
+ }\r
+\r
+ private void makeTaxonRelationship(TcsXmlImportState state, TaxonRelationshipType relType, TaxonBase fromTaxon, Taxon taxonTo, Reference citation, String microReference, ResultWrapper<Boolean> success){\r
+ TaxonRelationshipType taxRelType = relType;\r
+ if (! (fromTaxon instanceof Taxon )){\r
+ logger.warn("TaxonBase fromTaxon " + /*strTaxonAbout +*/ "is not of Type 'Taxon'. Relationship is not added.");\r
+ success.setValue(false);\r
+ }else{\r
+ Taxon taxonFrom = (Taxon)fromTaxon;\r
+ if (relType.equals(TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN())){\r
+ makeTaxonomicallyIncluded(state, taxonTo, taxonFrom, citation, microReference);\r
+ }else{\r
+ taxonFrom.addTaxonRelation(taxonTo, taxRelType, citation, microReference);\r
+ }\r
+ }\r
+ }\r
+\r
+ private boolean makeTaxonomicallyIncluded(TcsXmlImportState state, Taxon toTaxon, Taxon fromTaxon, Reference citation, String microCitation){\r
+ Reference sec = toTaxon.getSec();\r
+ Classification tree = state.getTree(sec);\r
+ if (tree == null){\r
+ tree = makeTree(state, sec);\r
+ }\r
+ TaxonNode childNode = tree.addParentChild(toTaxon, fromTaxon, citation, microCitation);\r
+ return (childNode != null);\r
+ }\r
+\r
+\r
+ @SuppressWarnings("rawtypes")\r
+ private TaxonBase getToTaxon(Element elTaxonRelationship, MapWrapper<TaxonBase> map, List<String> missingNameID,boolean isSynonym, ResultWrapper<Boolean> success, TcsXmlImportState state){\r
TaxonBase result = null;\r
if (elTaxonRelationship == null || map == null){\r
success.setValue(false);\r
String childName = "ToTaxonConcept";\r
boolean obligatory = true;\r
Element elToTaxonConcept = XmlHelp.getSingleChildElement(success, elTaxonRelationship, childName, elTaxonRelationship.getNamespace(), obligatory);\r
- \r
+\r
+\r
String linkType = elToTaxonConcept.getAttributeValue("linkType");\r
if (linkType == null || linkType.equals("local")){\r
String ref = elToTaxonConcept.getAttributeValue("ref");\r
if (ref != null){\r
result = map.get(ref);\r
+ if (result == null && state.getConfig().isDoGetMissingNames()){\r
+\r
+\r
+ String[] split= ref.split(":");\r
+ String id = split[split.length-1];\r
+ logger.info("get name for id " + id);\r
+ if (missingNameID.contains(id)){\r
+ return null;\r
+ }\r
+ InputStream nameStream = service.getNamesById(id);\r
+\r
+\r
+ try{\r
+ String nameUri = "urn:lsid:ipni.org:names:"+ id;\r
+ TaxonName name = rdfNameImport.handleRdfElementFromStream(nameStream, rdfConfig, (MapWrapper<TaxonName>)state.getStore(ICdmIO.TAXONNAME_STORE), nameUri);\r
+ if (name != null){\r
+ if (name.getTaxa().isEmpty()){\r
+\r
+ result = Taxon.NewInstance(name, null);\r
+ }else{\r
+ result = (TaxonBase)name.getTaxa().iterator().next();\r
+ }\r
+ name.addSource(OriginalSourceType.Import, ref, "TaxonConcept", null, null);\r
+ result.addSource(OriginalSourceType.Import, ref, "TaxonConcept", null, null);\r
+\r
+ map.put(removeVersionOfRef(ref), result);\r
+ } else{\r
+ missingNameID.add(id);\r
+ }\r
+ }catch(Exception e){\r
+ logger.debug(e.getMessage());\r
+ e.printStackTrace();\r
+ }\r
+ }\r
}else{\r
String title = elToTaxonConcept.getTextNormalize();\r
//TODO synonym?\r
- TaxonNameBase<?,?> taxonName = NonViralName.NewInstance(null);\r
- taxonName.setTitleCache(title);\r
+ TaxonName taxonName = TaxonNameFactory.NewNonViralInstance(null);\r
+ taxonName.setTitleCache(title, true);\r
logger.warn("Free text related taxon seems to be bug in TCS");\r
if (isSynonym){\r
result = Synonym.NewInstance(taxonName, TcsXmlTaxonImport.unknownSec());\r
}else{\r
- result = Taxon.NewInstance(taxonName, TcsXmlTaxonImport.unknownSec()); \r
+ result = Taxon.NewInstance(taxonName, TcsXmlTaxonImport.unknownSec());\r
}\r
- result.setTitleCache(title);\r
+ result.setTitleCache(title, true);\r
}\r
}else{\r
logger.warn("External link types for synonym not yet implemented");\r
}\r
return result;\r
}\r
- \r
\r
- \r
- \r
- \r
- private boolean relationExists(Taxon taxonTo, Synonym synonym, SynonymRelationshipType synRelType){\r
- if (synonym == null){\r
+ private boolean relationExists(Taxon taxonTo, Synonym synonym, SynonymType synRelType){\r
+ if (synonym == null || taxonTo == null\r
+ || !taxonTo.equals(synonym.getAcceptedTaxon())){\r
return false;\r
- }\r
- if (synonym.getRelationType(taxonTo).size() > 0){\r
- Set<SynonymRelationshipType> relTypeList = synonym.getRelationType(taxonTo);\r
- if (relTypeList.contains(synRelType)){\r
- return true;\r
- }else{\r
- logger.warn("Taxon-Synonym pair has 2 different SynonymRelationships. This is against the rules");\r
- return false;\r
- }\r
}else{\r
- return false;\r
+ return CdmUtils.nullSafeEqual(synonym.getType(),synRelType);\r
}\r
}\r
\r
private boolean makeHomotypicSynonymRelations(Taxon aboutTaxon){\r
- TaxonNameBase<?,?> aboutName = aboutTaxon.getName();\r
+ TaxonName aboutName = aboutTaxon.getName();\r
if (aboutName != null){\r
- Set<TaxonNameBase> typifiedNames = aboutName.getHomotypicalGroup().getTypifiedNames();\r
- for (TaxonNameBase<?,?> typifiedName : typifiedNames){\r
+ Set<TaxonName> typifiedNames = aboutName.getHomotypicalGroup().getTypifiedNames();\r
+ for (TaxonName typifiedName : typifiedNames){\r
//TODO check if name is part of this tcs file\r
if (typifiedName.equals(aboutName)){\r
continue;\r
}\r
Set<Synonym> syns = typifiedName.getSynonyms();\r
for(Synonym syn:syns){\r
- aboutTaxon.addSynonym(syn, SynonymRelationshipType.HOMOTYPIC_SYNONYM_OF());\r
+ aboutTaxon.addSynonym(syn, SynonymType.HOMOTYPIC_SYNONYM_OF());\r
}\r
}\r
}\r
return true;\r
}\r
- \r
- /* (non-Javadoc)\r
- * @see eu.etaxonomy.cdm.io.common.CdmIoBase#isIgnore(eu.etaxonomy.cdm.io.common.IImportConfigurator)\r
- */\r
- protected boolean isIgnore(IImportConfigurator config){\r
- return ! config.isDoRelTaxa();\r
+\r
+ @Override\r
+ protected boolean isIgnore(TcsXmlImportState state){\r
+ return ! state.getConfig().isDoRelTaxa();\r
}\r
- \r
}\r
BGBM BDI Projects / cdmlib.git / blobdiff