*\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
\r
package eu.etaxonomy.cdm.io.tcsxml.in;\r
\r
-import java.io.BufferedInputStream;\r
-import java.io.IOException;\r
import java.io.InputStream;\r
import java.util.ArrayList;\r
import java.util.HashSet;\r
import java.util.Set;\r
\r
import org.apache.log4j.Logger;\r
-import org.jdom.Attribute;\r
import org.jdom.Element;\r
-import org.jdom.JDOMException;\r
import org.jdom.Namespace;\r
import org.springframework.beans.factory.annotation.Autowired;\r
import org.springframework.stereotype.Component;\r
\r
-import com.ibm.lsid.server.soap.InputStreamDataSource;\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.ext.ipni.IpniService;\r
import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;\r
import eu.etaxonomy.cdm.io.common.ICdmIO;\r
-import eu.etaxonomy.cdm.io.common.ImportHelper;\r
import eu.etaxonomy.cdm.io.common.MapWrapper;\r
-import eu.etaxonomy.cdm.io.tcsxml.TcsXmlTransformer;\r
import eu.etaxonomy.cdm.io.tcsrdf.TcsRdfImportConfigurator;\r
import eu.etaxonomy.cdm.io.tcsrdf.TcsRdfTaxonNameImport;\r
-import eu.etaxonomy.cdm.io.tcsrdf.TcsRdfTransformer;\r
-import eu.etaxonomy.cdm.model.agent.Team;\r
-import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase;\r
+import eu.etaxonomy.cdm.io.tcsxml.TcsXmlTransformer;\r
import eu.etaxonomy.cdm.model.common.CdmBase;\r
-import eu.etaxonomy.cdm.model.common.Marker;\r
-import eu.etaxonomy.cdm.model.common.MarkerType;\r
import eu.etaxonomy.cdm.model.common.OriginalSourceType;\r
import eu.etaxonomy.cdm.model.common.RelationshipTermBase;\r
-import eu.etaxonomy.cdm.model.common.TimePeriod;\r
import eu.etaxonomy.cdm.model.description.CommonTaxonName;\r
import eu.etaxonomy.cdm.model.description.TaxonDescription;\r
-import eu.etaxonomy.cdm.model.name.BotanicalName;\r
-import eu.etaxonomy.cdm.model.name.NomenclaturalCode;\r
-import eu.etaxonomy.cdm.model.name.NomenclaturalStatus;\r
-import eu.etaxonomy.cdm.model.name.NomenclaturalStatusType;\r
-import eu.etaxonomy.cdm.model.name.NonViralName;\r
-import eu.etaxonomy.cdm.model.name.Rank;\r
-import eu.etaxonomy.cdm.model.name.TaxonNameBase;\r
-import eu.etaxonomy.cdm.model.reference.IGeneric;\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.reference.ReferenceFactory;\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.model.taxon.Classification;\r
import eu.etaxonomy.cdm.strategy.exceptions.UnknownCdmTypeException;\r
\r
\r
*/\r
@Component\r
public class TcsXmlTaxonRelationsImport extends TcsXmlImportBase implements ICdmIO<TcsXmlImportState> {\r
- private static final Logger logger = Logger.getLogger(TcsXmlTaxonRelationsImport.class);\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
+\r
@Autowired\r
private TcsRdfTaxonNameImport rdfNameImport;\r
private TcsRdfImportConfigurator rdfConfig = TcsRdfImportConfigurator.NewInstance(null, null);\r
- \r
+\r
public TcsXmlTaxonRelationsImport(){\r
super();\r
- \r
+\r
}\r
- \r
+\r
@Override\r
public boolean doCheck(TcsXmlImportState state){\r
boolean result = true;\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 void 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<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
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 == null ? new ArrayList<Element>() : elTaxonConcepts.getChildren(childName, tcsNamespace);\r
- \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(state, taxonMap, taxonStore, elTaxonConcept, tcsNamespace, success); \r
+ taxonRelCount += makeTaxonConcept(state, taxonMap, taxonStore, elTaxonConcept, tcsNamespace, success);\r
}//elTaxonConcept\r
logger.info("Taxa handled: " + taxonStore.size());\r
//TaxonRelationshipAssertions\r
- taxonRelCount += makeTaxonRelationshipAssertion(state, 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().save(taxonStore);\r
- \r
+\r
//do basionym relationships\r
childName = "TaxonNames";\r
obligatory = false;\r
Element elTaxonNames = XmlHelp.getSingleChildElement(success, elDataSet, childName, tcsNamespace, obligatory);\r
- \r
+\r
childName = "TaxonName";\r
List<Element> elTaxonNameList = elTaxonNames == null ? new ArrayList<Element>() : elTaxonNames.getChildren(childName, tcsNamespace);\r
- \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
+ taxonRelCount += makeBasionymRelations(state, taxonMap, taxonNameMap, taxonStore, elTaxonName, tcsNamespace, success);\r
}//elTaxonConcept\r
logger.info("Taxa handled: " + taxonStore.size());\r
- \r
- \r
+\r
+\r
taxonStore = null;\r
logger.info("end make taxon relations ...");\r
if (!success.getValue()){\r
}\r
return;\r
}\r
- \r
+\r
private int makeBasionymRelations(TcsXmlImportState state,\r
- MapWrapper<TaxonBase> taxonMap, MapWrapper<TaxonNameBase> taxonNameMap, Set<TaxonBase> taxonStore,\r
+ MapWrapper<TaxonBase> taxonMap, MapWrapper<TaxonName> taxonNameMap, Set<TaxonBase> taxonStore,\r
Element elTaxonName, Namespace tcsNamespace,\r
ResultWrapper<Boolean> success) {\r
\r
<tcs:RelatedName ref="urn:lsid:ipni.org:names:50000063-1">Caryophyllaceae</tcs:RelatedName>\r
</tcs:Basionym>\r
*/\r
- \r
- \r
+\r
+\r
String childName = "Basionym";\r
boolean obligatory = false;\r
Element elBasionymRelationships = XmlHelp.getSingleChildElement(success, elTaxonName, childName, tcsNamespace, obligatory);\r
childName = "RelatedName";\r
obligatory = false;\r
Element elBasionym = XmlHelp.getSingleChildElement(success, elBasionymRelationships, childName, tcsNamespace, obligatory);\r
- \r
+\r
String id = elTaxonName.getAttributeValue("id");\r
- TaxonNameBase name = taxonNameMap.get(removeVersionOfRef(id));\r
+ TaxonName name = taxonNameMap.get(removeVersionOfRef(id));\r
+\r
TaxonBase taxonBase = (TaxonBase)name.getTaxonBases().iterator().next();\r
- \r
+\r
String ref = elBasionym.getAttributeValue("ref");\r
- TaxonNameBase basionymName = taxonNameMap.get(removeVersionOfRef(ref));\r
- \r
+ TaxonName basionymName = taxonNameMap.get(removeVersionOfRef(ref));\r
+\r
if (basionymName != null){\r
- basionymName = HibernateProxyHelper.deproxy(basionymName, TaxonNameBase.class);\r
+ basionymName = HibernateProxyHelper.deproxy(basionymName, TaxonName.class);\r
TaxonBase basionym;\r
if (basionymName.getTaxonBases().isEmpty()){\r
basionym = Synonym.NewInstance(basionymName, null);\r
}\r
//Synonym basionymSyn;\r
if (basionym instanceof Taxon){\r
- \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
- System.out.println("The taxon " + basionymName.getTitleCache() + " is used in a concept and can not be used as basionym of " + name.getTitleCache());\r
- basionymName.getHomotypicalGroup().setGroupBasionym(basionymName);\r
- basionymName.getHomotypicalGroup().addTypifiedName(name);\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, SynonymRelationshipType.HOMOTYPIC_SYNONYM_OF());\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, SynonymRelationshipType.HOMOTYPIC_SYNONYM_OF());\r
+ ((Taxon)taxonBase).addSynonym(synonym, SynonymType.HOMOTYPIC_SYNONYM_OF());\r
taxonBase.getHomotypicGroup().setGroupBasionym(basionymName);\r
taxonStore.add(taxonBase);\r
} else{\r
- if (((Synonym)taxonBase).getAcceptedTaxa().iterator().hasNext()){\r
- Taxon acc = ((Synonym)taxonBase).getAcceptedTaxa().iterator().next();\r
- \r
- acc.addHomotypicSynonym((Synonym)basionym, null, null);\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
+\r
+\r
} else{\r
- basionymName = NonViralName.NewInstance(name.getRank());\r
+ basionymName = TaxonNameFactory.NewNonViralInstance(name.getRank());\r
childName = "RelatedName";\r
obligatory = true;\r
Element elName = XmlHelp.getSingleChildElement(success, elBasionym, childName, tcsNamespace, obligatory);\r
Synonym basionymSyn = Synonym.NewInstance(basionymName, unknownSec());\r
if (taxonBase instanceof Taxon){\r
Taxon taxon = (Taxon)taxonBase;\r
- taxon.addSynonym(basionymSyn, SynonymRelationshipType.HOMOTYPIC_SYNONYM_OF());\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.getAcceptedTaxa().isEmpty()){\r
- Taxon accTaxon = (Taxon)syn.getAcceptedTaxa().iterator().next();\r
- accTaxon.addSynonym(basionymSyn, SynonymRelationshipType.HOMOTYPIC_SYNONYM_OF());\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
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
logger.info("Number of taxonrelationships: " + elTaxonRelationshipList.size());\r
for (Element elTaxonRelationship: elTaxonRelationshipList){\r
- \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
+\r
TaxonBase fromTaxon = taxonMap.get(removeVersionOfRef(strId));\r
makeRelationshipType(state, elTaxonRelationship, taxonMap, taxonStore, fromTaxon, success);\r
- \r
+\r
if (fromTaxon instanceof Taxon){\r
makeHomotypicSynonymRelations((Taxon)fromTaxon);\r
}\r
}\r
\r
private int makeTaxonRelationshipAssertion(\r
- TcsXmlImportState state, \r
+ TcsXmlImportState state,\r
MapWrapper<TaxonBase> taxonMap,\r
MapWrapper<Reference> referenceMap,\r
- Set<TaxonBase> taxonStore, \r
- Element elDataSet, \r
- Namespace tcsNamespace, \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
Reference ref = makeAccordingTo(elAccordingTo, referenceMap, success);\r
- \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
+\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
*/\r
private void makeRelationshipType(\r
TcsXmlImportState state\r
- , Element elRelationship \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
handleVernacular(success, state, elRelationship, fromTaxon);\r
}else{\r
RelationshipTermBase<?> relType = TcsXmlTransformer.tcsRelationshipType2Relationship(strRelType, isInverse);\r
- \r
+\r
//toTaxon (should be part of relationshipType)\r
- boolean isSynonym = (relType instanceof SynonymRelationshipType);\r
+ boolean isSynonym = (relType instanceof SynonymType);\r
TaxonBase toTaxon = getToTaxon(elRelationship, taxonMap, state.getMissingConceptLSIDs(), isSynonym, success, state);\r
- \r
+\r
if (toTaxon != null && fromTaxon != null){\r
//exchange taxa if relationship is inverse\r
if (isInverse.getValue() == true ){\r
toTaxon = fromTaxon;\r
fromTaxon = tmp;\r
}\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
- Reference citation = null;\r
- String microReference = null;\r
- if (relType instanceof SynonymRelationshipType){\r
- SynonymRelationshipType synRelType = (SynonymRelationshipType)relType;\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
- TaxonNameBase<?,?> synName = synonym.getName();\r
- TaxonNameBase<?,?> accName = taxonTo.getName();\r
+ TaxonName synName = synonym.getName();\r
+ TaxonName 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
+ && ( synRelType.equals(SynonymType.SYNONYM_OF()))){\r
+ synRelType = SynonymType.HOMOTYPIC_SYNONYM_OF();\r
}\r
if (! relationExists(taxonTo, synonym, synRelType)){\r
- taxonTo.addSynonym(synonym, synRelType, citation, microReference); \r
+ taxonTo.addSynonym(synonym, synRelType);\r
}else{\r
//TODO citation, microReference\r
//TODO different synRelTypes -> warning\r
}\r
}\r
}else if (relType instanceof TaxonRelationshipType){\r
- makeTaxonRelationship(state, (TaxonRelationshipType)relType, fromTaxon, taxonTo, citation, microReference, success);\r
+ Reference citation = null;\r
+ String microReference = null;\r
+ makeTaxonRelationship(state, (TaxonRelationshipType)relType, fromTaxon, taxonTo, citation, microReference, success);\r
}else{\r
logger.warn("Unknown Relationshiptype");\r
success.setValue(false);\r
}\r
success.setValue(false);\r
}\r
- } \r
+ }\r
} catch (UnknownCdmTypeException e) {\r
//TODO\r
logger.warn("relationshipType " + strRelType + " not yet implemented");\r
}\r
return;\r
}\r
- \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
description.addElement(commonTaxonName);\r
}\r
}\r
- \r
+\r
private TaxonDescription getDescription(Taxon taxon) {\r
if (taxon.getDescriptions().isEmpty()){\r
return TaxonDescription.NewInstance(taxon);\r
String childName = "ToTaxonConcept";\r
boolean obligatory = true;\r
Element elToTaxonConcept = XmlHelp.getSingleChildElement(success, elTaxonRelationship, childName, elTaxonRelationship.getNamespace(), obligatory);\r
- \r
+\r
String linkType = elToTaxonConcept.getAttributeValue("linkType");\r
if (linkType == null || linkType.equals("local")){\r
String ref = elToTaxonConcept.getAttributeValue("ref");\r
}\r
\r
private void makeTaxonRelationship(TcsXmlImportState state, TaxonRelationshipType relType, TaxonBase fromTaxon, Taxon taxonTo, Reference citation, String microReference, ResultWrapper<Boolean> success){\r
- TaxonRelationshipType taxRelType = (TaxonRelationshipType)relType;\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
}\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
TaxonNode childNode = tree.addParentChild(toTaxon, fromTaxon, citation, microCitation);\r
return (childNode != null);\r
}\r
- \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
String childName = "ToTaxonConcept";\r
boolean obligatory = true;\r
Element elToTaxonConcept = XmlHelp.getSingleChildElement(success, elTaxonRelationship, childName, elTaxonRelationship.getNamespace(), obligatory);\r
- \r
- /* <tcs:TaxonConcept id="urn:lsid:ipni.test:concepts:1670-2:1.2">\r
- <tcs:Name scientific="true" ref="urn:lsid:ipni.org:names:1670-2:1.2"></tcs:Name>\r
- <tcs:TaxonRelationships>\r
- <tcs:TaxonRelationship type="is child taxon of">\r
- <tcs:ToTaxonConcept ref="urn:lsid:ipni.test:concepts:30216889-2"></tcs:ToTaxonConcept>\r
- </tcs:TaxonRelationship>\r
- </tcs:TaxonRelationships>\r
- </tcs:TaxonConcept>\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){\r
- \r
- \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
+\r
try{\r
String nameUri = "urn:lsid:ipni.org:names:"+ id;\r
- TaxonNameBase name = rdfNameImport.handleRdfElementFromStream(nameStream, rdfConfig, (MapWrapper<TaxonNameBase>)state.getStore(ICdmIO.TAXONNAME_STORE), nameUri);\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
+\r
result = Taxon.NewInstance(name, null);\r
}else{\r
- System.out.println(name.getTitleCache());\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
+\r
map.put(removeVersionOfRef(ref), result);\r
+ } else{\r
+ missingNameID.add(id);\r
}\r
}catch(Exception e){\r
logger.debug(e.getMessage());\r
}else{\r
String title = elToTaxonConcept.getTextNormalize();\r
//TODO synonym?\r
- TaxonNameBase<?,?> taxonName = NonViralName.NewInstance(null);\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, true);\r
}\r
}\r
return result;\r
}\r
- \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
- \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(TcsXmlImportState state){\r
+\r
+ @Override\r
+ protected boolean isIgnore(TcsXmlImportState state){\r
return ! state.getConfig().isDoRelTaxa();\r
}\r
- \r
- \r
- \r
}\r
BGBM BDI Projects / cdmlib.git / blobdiff