<mapping class="eu.etaxonomy.cdm.model.term.TermRelationshipType"/>
<mapping class="eu.etaxonomy.cdm.model.term.TermTree"/>
<mapping class="eu.etaxonomy.cdm.model.term.TermGraph"/>
- <mapping class="eu.etaxonomy.cdm.model.term.TermTreeNode"/>
+ <mapping class="eu.etaxonomy.cdm.model.term.TermNode"/>
<mapping class="eu.etaxonomy.cdm.model.term.TermRelation"/>
<mapping class="eu.etaxonomy.cdm.model.term.TermVocabulary"/>
-/**\r
-* Copyright (C) 2019 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
-package eu.etaxonomy.cdm.io.descriptive.owl.in;\r
-\r
-import java.net.URI;\r
-import java.util.Collections;\r
-import java.util.HashSet;\r
-import java.util.List;\r
-import java.util.Set;\r
-import java.util.UUID;\r
-\r
-import com.hp.hpl.jena.rdf.model.Model;\r
-import com.hp.hpl.jena.rdf.model.Resource;\r
-import com.hp.hpl.jena.rdf.model.Statement;\r
-\r
-import eu.etaxonomy.cdm.api.application.ICdmRepository;\r
-import eu.etaxonomy.cdm.common.CdmUtils;\r
-import eu.etaxonomy.cdm.io.descriptive.owl.OwlUtil;\r
-import eu.etaxonomy.cdm.model.common.IdentifiableSource;\r
-import eu.etaxonomy.cdm.model.common.Language;\r
-import eu.etaxonomy.cdm.model.description.Character;\r
-import eu.etaxonomy.cdm.model.description.Feature;\r
-import eu.etaxonomy.cdm.model.description.MeasurementUnit;\r
-import eu.etaxonomy.cdm.model.description.State;\r
-import eu.etaxonomy.cdm.model.description.StatisticalMeasure;\r
-import eu.etaxonomy.cdm.model.media.Media;\r
-import eu.etaxonomy.cdm.model.reference.OriginalSourceType;\r
-import eu.etaxonomy.cdm.model.reference.Reference;\r
-import eu.etaxonomy.cdm.model.reference.ReferenceFactory;\r
-import eu.etaxonomy.cdm.model.term.DefinedTerm;\r
-import eu.etaxonomy.cdm.model.term.DefinedTermBase;\r
-import eu.etaxonomy.cdm.model.term.Representation;\r
-import eu.etaxonomy.cdm.model.term.TermTreeNode;\r
-import eu.etaxonomy.cdm.model.term.TermType;\r
-import eu.etaxonomy.cdm.model.term.TermVocabulary;\r
-\r
-/**\r
- * @author pplitzner\r
- * @since May 26, 2019\r
- *\r
- */\r
-public class OwlImportUtil {\r
-\r
- static final org.apache.log4j.Logger logger = org.apache.log4j.Logger.getLogger(OwlImportUtil.class);\r
-\r
- private static void addFeatureProperties(Feature feature, Resource termResource, ICdmRepository repo, Model model, StructureTreeOwlImportState state){\r
- if(termResource.hasProperty(OwlUtil.propFeatureIsCategorical)){\r
- feature.setSupportsCategoricalData(termResource.getProperty(OwlUtil.propFeatureIsCategorical).getBoolean());\r
- }\r
- if(termResource.hasProperty(OwlUtil.propFeatureIsQuantitative)){\r
- feature.setSupportsQuantitativeData(termResource.getProperty(OwlUtil.propFeatureIsQuantitative).getBoolean());\r
- }\r
- // import measurement units\r
- Set<MeasurementUnit> measurementUnits = new HashSet<>();\r
- List<Statement> measurementUnitStatements = termResource.listProperties(OwlUtil.propFeatureHasRecommendedMeasurementUnit).toList();\r
- for (Statement statement : measurementUnitStatements) {\r
- Resource measurementUnitResource = model.createResource(statement.getObject().toString());\r
- MeasurementUnit measurementUnit = findTerm(MeasurementUnit.class, measurementUnitResource, repo, model, state);\r
- if(measurementUnit==null){\r
- measurementUnit = MeasurementUnit.NewInstance();\r
- addTermProperties(measurementUnit, measurementUnitResource, repo, model, state);\r
- }\r
- measurementUnits.add(measurementUnit);\r
- }\r
- measurementUnits.forEach(unit->feature.addRecommendedMeasurementUnit(unit));\r
- // import modifier TODO: create entire vocabulary if it cannot be found\r
- Set<TermVocabulary<DefinedTerm>> modifierVocs = new HashSet<>();\r
- List<Statement> modifierEnumStatements = termResource.listProperties(OwlUtil.propFeatureHasRecommendedModifierEnumeration).toList();\r
- for (Statement statement : modifierEnumStatements) {\r
- Resource modifierEnumResource = model.createResource(statement.getObject().toString());\r
- TermVocabulary modifierVoc = findVocabulary(modifierEnumResource, repo, model, state);\r
- if(modifierVoc!=null){\r
- modifierVocs.add(modifierVoc);\r
- }\r
- }\r
- modifierVocs.forEach(modiferVoc->feature.addRecommendedModifierEnumeration(modiferVoc));\r
- // import statistical measures\r
- Set<StatisticalMeasure> statisticalMeasures = new HashSet<>();\r
- List<Statement> statisticalMeasureStatements = termResource.listProperties(OwlUtil.propFeatureHasRecommendedStatisticalMeasure).toList();\r
- for (Statement statement : statisticalMeasureStatements) {\r
- Resource statisticalMeasureResource = model.createResource(statement.getObject().toString());\r
- StatisticalMeasure statisticalMeasure = findTerm(StatisticalMeasure.class, statisticalMeasureResource, repo, model, state);\r
- if(statisticalMeasure==null){\r
- statisticalMeasure = StatisticalMeasure.NewInstance();\r
- addTermProperties(statisticalMeasure, statisticalMeasureResource, repo, model, state);\r
- }\r
- statisticalMeasures.add(statisticalMeasure);\r
- }\r
- statisticalMeasures.forEach(statisticalMeasure->feature.addRecommendedStatisticalMeasure(statisticalMeasure));\r
- // import categorical enums TODO: create entire vocabulary if it cannot be found\r
- Set<TermVocabulary<State>> stateVocs = new HashSet<>();\r
- List<Statement> stateVocStatements = termResource.listProperties(OwlUtil.propFeatureHasSupportedCategoricalEnumeration).toList();\r
- for (Statement statement : stateVocStatements) {\r
- Resource stateVocResource = model.createResource(statement.getObject().toString());\r
- TermVocabulary stateVoc = findVocabulary(stateVocResource, repo, model, state);\r
- if(stateVoc!=null){\r
- stateVocs.add(stateVoc);\r
- }\r
- }\r
- stateVocs.forEach(stateVoc->feature.addSupportedCategoricalEnumeration(stateVoc));\r
- }\r
-\r
- private static void addCharacterProperties(Character character, Resource termResource, ICdmRepository repo, Model model, StructureTreeOwlImportState state){\r
- addFeatureProperties(character, termResource, repo, model, state);\r
- // TODO import/export of complete term tree of structures and properties belonging to a character is necessary\r
- // import structure\r
- Statement structureStatement = termResource.getProperty(OwlUtil.propCharacterHasStructure);\r
- Resource structureResource = model.createResource(structureStatement.getObject().toString());\r
- TermTreeNode structureNode = findNode(structureResource, repo, model, state);\r
- if(structureNode!=null){\r
- character.setStructure(structureNode);\r
- }\r
- // import property\r
- Statement propertyStatement = termResource.getProperty(OwlUtil.propCharacterHasProperty);\r
- Resource propertyResource = model.createResource(propertyStatement.getObject().toString());\r
- TermTreeNode propertyNode = findNode(propertyResource, repo, model, state);\r
- if(propertyNode!=null){\r
- character.setProperty(propertyNode);\r
- }\r
- // import structure modifier\r
- if(termResource.hasProperty(OwlUtil.propCharacterHasStructureModfier)){\r
- Statement structureModifierStatement = termResource.getProperty(OwlUtil.propCharacterHasStructureModfier);\r
- Resource structureModifierResource = model.createResource(structureModifierStatement.getObject().toString());\r
- DefinedTerm structureModifier = findTerm(DefinedTerm.class, structureModifierResource, repo, model, state);\r
- character.setStructureModifier(structureModifier);\r
- }\r
- }\r
-\r
- private static void addTermProperties(DefinedTermBase term, Resource termResource, ICdmRepository repo, Model model, StructureTreeOwlImportState state){\r
- term.setUuid(UUID.fromString(termResource.getProperty(OwlUtil.propUuid).getString()));\r
-\r
- // term URI\r
- String uriString = termResource.hasProperty(OwlUtil.propUri)?termResource.getProperty(OwlUtil.propUri).getString():null;\r
- if(CdmUtils.isNotBlank(uriString)){\r
- term.setUri(URI.create(uriString));\r
- }\r
- // symbol\r
- String symbolString = termResource.hasProperty(OwlUtil.propTermSymbol)?termResource.getProperty(OwlUtil.propTermSymbol).getString():null;\r
- if(CdmUtils.isNotBlank(symbolString)){\r
- term.setSymbol(symbolString);\r
- }\r
- // symbol2\r
- String symbol2String = termResource.hasProperty(OwlUtil.propTermSymbol2)?termResource.getProperty(OwlUtil.propTermSymbol2).getString():null;\r
- if(CdmUtils.isNotBlank(symbol2String)){\r
- term.setSymbol2(symbol2String);\r
- }\r
- // idInVocabulary\r
- String idInVocabularyString = termResource.hasProperty(OwlUtil.propTermIdInVocabulary)?termResource.getProperty(OwlUtil.propTermIdInVocabulary).getString():null;\r
- if(CdmUtils.isNotBlank(idInVocabularyString)){\r
- term.setIdInVocabulary(idInVocabularyString);\r
- }\r
-\r
- // import representations\r
- Set<Representation> representations = new HashSet<>();\r
- termResource.listProperties(OwlUtil.propHasRepresentation).forEachRemaining(r->representations.add(OwlImportUtil.createRepresentation(repo, r, model)));\r
- if(representations.isEmpty()){\r
- logger.error("No representations found for term: "+termResource.getProperty(OwlUtil.propUuid));\r
- }\r
- representations.forEach(rep->term.addRepresentation(rep));\r
-\r
- // import sources\r
- Set<IdentifiableSource> sources = new HashSet<>();\r
- termResource.listProperties(OwlUtil.propTermHasSource).forEachRemaining(sourceStatement->sources.add(OwlImportUtil.createSource(sourceStatement, repo, model)));\r
- sources.forEach(source->term.addSource(source));\r
-\r
- // add import source\r
- IdentifiableSource importSource = IdentifiableSource.NewDataImportInstance(termResource.getURI());\r
- importSource.setCitation(state.getConfig().getSourceReference());\r
- term.addSource(importSource);\r
- }\r
-\r
- private static <T extends DefinedTermBase> T findTerm(Class<T> clazz, Resource termResource, ICdmRepository repo, Model model, StructureTreeOwlImportState state){\r
- UUID termUuid = UUID.fromString(termResource.getProperty(OwlUtil.propUuid).getString());\r
- List<T> terms = repo.getTermService().find(clazz, Collections.singleton(termUuid));\r
- if(!terms.isEmpty()){\r
- return terms.iterator().next();\r
- }\r
- return null;\r
- }\r
-\r
- private static TermVocabulary findVocabulary(Resource termResource, ICdmRepository repo, Model model, StructureTreeOwlImportState state){\r
- UUID termUuid = UUID.fromString(termResource.getProperty(OwlUtil.propUuid).getString());\r
- return repo.getVocabularyService().find(termUuid);\r
- }\r
-\r
- private static TermTreeNode findNode(Resource termResource, ICdmRepository repo, Model model, StructureTreeOwlImportState state){\r
- UUID uuid = UUID.fromString(termResource.getProperty(OwlUtil.propUuid).getString());\r
- return repo.getFeatureNodeService().find(uuid);\r
- }\r
-\r
- private static Reference findReference(Resource resource, ICdmRepository repo){\r
- UUID uuid = UUID.fromString(resource.getProperty(OwlUtil.propUuid).getString());\r
- return repo.getReferenceService().find(uuid);\r
- }\r
-\r
- static Media findMedia(Resource resource, ICdmRepository repo){\r
- UUID uuid = UUID.fromString(resource.getProperty(OwlUtil.propUuid).getString());\r
- return repo.getMediaService().find(uuid);\r
- }\r
-\r
- static Feature createFeature(Resource termResource, ICdmRepository repo, Model model, StructureTreeOwlImportState state){\r
- Feature feature = findTerm(Feature.class, termResource, repo, model, state);\r
- if(feature==null){\r
- feature = Feature.NewInstance();\r
- addFeatureProperties(feature, termResource, repo, model, state);\r
- }\r
- return feature;\r
- }\r
-\r
- private static Character createCharacter(Resource termResource, ICdmRepository repo, Model model, StructureTreeOwlImportState state){\r
- Character character = findTerm(Character.class, termResource, repo, model, state);\r
- if(character==null){\r
- character = Character.NewInstance();\r
- addCharacterProperties(character, termResource, repo, model, state);\r
- }\r
- return character;\r
- }\r
-\r
- static DefinedTermBase createTerm(Resource termResource, ICdmRepository repo, Model model, StructureTreeOwlImportState state){\r
- TermType termType = TermType.getByKey(termResource.getProperty(OwlUtil.propType).getString());\r
- DefinedTermBase term = null;\r
- // create new term\r
- if(termType.equals(TermType.Feature)){\r
- term = createFeature(termResource, repo, model, state);\r
- }\r
- else if(termType.equals(TermType.Character)){\r
- term = createCharacter(termResource, repo, model, state);\r
- }\r
- else{\r
- term = DefinedTerm.NewInstance(termType);\r
- }\r
- addTermProperties(term, termResource, repo, model, state);\r
- return term;\r
- }\r
-\r
- static IdentifiableSource createSource(Statement sourceStatement, ICdmRepository repo, Model model) {\r
- Resource sourceResource = model.createResource(sourceStatement.getObject().toString());\r
-\r
- String typeString = sourceResource.getProperty(OwlUtil.propSourceType).getString();\r
- IdentifiableSource source = IdentifiableSource.NewInstance(OriginalSourceType.getByKey(typeString));\r
-\r
- if(sourceResource.hasProperty(OwlUtil.propSourceIdInSource)){\r
- String idInSource = sourceResource.getProperty(OwlUtil.propSourceIdInSource).getString();\r
- source.setIdInSource(idInSource);\r
- }\r
-\r
- // import citation\r
- List<Statement> citationStatements = sourceResource.listProperties(OwlUtil.propSourceHasCitation).toList();\r
- if(citationStatements.size()>1){\r
- logger.error("More than one citations found for source. Choosing one arbitrarily. - "+sourceResource.toString());\r
- }\r
- if(!citationStatements.isEmpty()){\r
- Statement citationStatement = citationStatements.iterator().next();\r
- Resource citationResource = model.createResource(citationStatement.getObject().toString());\r
- Reference reference = findReference(citationResource, repo);\r
- if(reference==null){\r
- reference = createReference(citationResource, model);\r
- }\r
- source.setCitation(reference);\r
- }\r
- return source;\r
- }\r
-\r
- static Reference createReference(Resource citationResource, Model model){\r
- String titleString = citationResource.getProperty(OwlUtil.propReferenceTitle).getString();\r
- Reference citation = ReferenceFactory.newGeneric();\r
- citation.setTitle(titleString);\r
- return citation;\r
- }\r
-\r
- static TermVocabulary createVocabulary(Resource vocabularyResource, ICdmRepository repo, Model model, StructureTreeOwlImportState state){\r
- TermType termType = TermType.getByKey(vocabularyResource.getProperty(OwlUtil.propType).getString());\r
- // create new vocabulary\r
- TermVocabulary vocabulary = TermVocabulary.NewInstance(termType);\r
- vocabulary.setUuid(UUID.fromString(vocabularyResource.getProperty(OwlUtil.propUuid).getString()));\r
-\r
- // voc URI\r
- String vocUriString = vocabularyResource.hasProperty(OwlUtil.propUri)?vocabularyResource.getProperty(OwlUtil.propUri).getString():null;\r
- if(CdmUtils.isNotBlank(vocUriString)){\r
- vocabulary.setUri(URI.create(vocUriString));\r
- }\r
-\r
- // voc representations\r
- Set<Representation> vocRepresentations = new HashSet<>();\r
- vocabularyResource.listProperties(OwlUtil.propHasRepresentation).forEachRemaining(r->vocRepresentations.add(OwlImportUtil.createRepresentation(repo, r, model)));\r
- if(vocRepresentations.isEmpty()){\r
- logger.error("No representations found for vocabulary: "+vocabularyResource.getProperty(OwlUtil.propUuid));\r
- }\r
- vocRepresentations.forEach(rep->vocabulary.addRepresentation(rep));\r
-\r
- IdentifiableSource importSource = IdentifiableSource.NewDataImportInstance(vocabularyResource.getURI());\r
- importSource.setCitation(state.getConfig().getSourceReference());\r
- vocabulary.addSource(importSource);\r
-\r
-\r
- return vocabulary;\r
- }\r
-\r
- static Media createMedia(Resource mediaResource, StructureTreeOwlImportState state){\r
- URI mediaUri = URI.create(mediaResource.getProperty(OwlUtil.propMediaUri).getString());\r
- // create new media\r
- Media media = Media.NewInstance(mediaUri, null, null, null);\r
- media.setUuid(UUID.fromString(mediaResource.getProperty(OwlUtil.propUuid).getString()));\r
-\r
- if(mediaResource.hasProperty(OwlUtil.propMediaTitle)){\r
- // TODO: support multiple language titles\r
- media.putTitle(Language.DEFAULT(), mediaResource.getProperty(OwlUtil.propMediaTitle).getString());\r
- }\r
-\r
- IdentifiableSource importSource = IdentifiableSource.NewDataImportInstance(mediaResource.getURI());\r
- importSource.setCitation(state.getConfig().getSourceReference());\r
- media.addSource(importSource);\r
-\r
- return media;\r
- }\r
-\r
- static Representation createRepresentation(ICdmRepository repo, Statement repr, Model model) {\r
- Resource repsentationResource = model.createResource(repr.getObject().toString());\r
-\r
- String languageLabel = repsentationResource.getProperty(OwlUtil.propLanguage).getString();\r
- UUID languageUuid = UUID.fromString(repsentationResource.getProperty(OwlUtil.propLanguageUuid).getString());\r
- Language language = Language.getLanguageFromUuid(languageUuid);\r
- if(language==null){\r
- language = repo.getTermService().getLanguageByLabel(languageLabel);\r
- }\r
- if(language==null){\r
- language = Language.getDefaultLanguage();\r
- }\r
-\r
- String abbreviatedLabel = repsentationResource.hasProperty(OwlUtil.propLabelAbbrev)?repsentationResource.getProperty(OwlUtil.propLabelAbbrev).getString():null;\r
- String plural = repsentationResource.hasProperty(OwlUtil.propLabelPlural)?repsentationResource.getProperty(OwlUtil.propLabelPlural).getString():null;\r
- String label = repsentationResource.getProperty(OwlUtil.propLabel).getString();\r
- String description = repsentationResource.hasProperty(OwlUtil.propDescription)?repsentationResource.getProperty(OwlUtil.propDescription).getString():null;\r
- Representation representation = Representation.NewInstance(description, label, abbreviatedLabel, language);\r
- representation.setPlural(plural);\r
-\r
- return representation;\r
- }\r
-\r
-}\r
+/**
+* Copyright (C) 2019 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.descriptive.owl.in;
+
+import java.net.URI;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+
+import com.hp.hpl.jena.rdf.model.Model;
+import com.hp.hpl.jena.rdf.model.Resource;
+import com.hp.hpl.jena.rdf.model.Statement;
+
+import eu.etaxonomy.cdm.api.application.ICdmRepository;
+import eu.etaxonomy.cdm.common.CdmUtils;
+import eu.etaxonomy.cdm.io.descriptive.owl.OwlUtil;
+import eu.etaxonomy.cdm.model.common.IdentifiableSource;
+import eu.etaxonomy.cdm.model.common.Language;
+import eu.etaxonomy.cdm.model.description.Character;
+import eu.etaxonomy.cdm.model.description.Feature;
+import eu.etaxonomy.cdm.model.description.MeasurementUnit;
+import eu.etaxonomy.cdm.model.description.State;
+import eu.etaxonomy.cdm.model.description.StatisticalMeasure;
+import eu.etaxonomy.cdm.model.media.Media;
+import eu.etaxonomy.cdm.model.reference.OriginalSourceType;
+import eu.etaxonomy.cdm.model.reference.Reference;
+import eu.etaxonomy.cdm.model.reference.ReferenceFactory;
+import eu.etaxonomy.cdm.model.term.DefinedTerm;
+import eu.etaxonomy.cdm.model.term.DefinedTermBase;
+import eu.etaxonomy.cdm.model.term.Representation;
+import eu.etaxonomy.cdm.model.term.TermNode;
+import eu.etaxonomy.cdm.model.term.TermType;
+import eu.etaxonomy.cdm.model.term.TermVocabulary;
+
+/**
+ * @author pplitzner
+ * @since May 26, 2019
+ *
+ */
+public class OwlImportUtil {
+
+ static final org.apache.log4j.Logger logger = org.apache.log4j.Logger.getLogger(OwlImportUtil.class);
+
+ private static void addFeatureProperties(Feature feature, Resource termResource, ICdmRepository repo, Model model, StructureTreeOwlImportState state){
+ if(termResource.hasProperty(OwlUtil.propFeatureIsCategorical)){
+ feature.setSupportsCategoricalData(termResource.getProperty(OwlUtil.propFeatureIsCategorical).getBoolean());
+ }
+ if(termResource.hasProperty(OwlUtil.propFeatureIsQuantitative)){
+ feature.setSupportsQuantitativeData(termResource.getProperty(OwlUtil.propFeatureIsQuantitative).getBoolean());
+ }
+ // import measurement units
+ Set<MeasurementUnit> measurementUnits = new HashSet<>();
+ List<Statement> measurementUnitStatements = termResource.listProperties(OwlUtil.propFeatureHasRecommendedMeasurementUnit).toList();
+ for (Statement statement : measurementUnitStatements) {
+ Resource measurementUnitResource = model.createResource(statement.getObject().toString());
+ MeasurementUnit measurementUnit = findTerm(MeasurementUnit.class, measurementUnitResource, repo, model, state);
+ if(measurementUnit==null){
+ measurementUnit = MeasurementUnit.NewInstance();
+ addTermProperties(measurementUnit, measurementUnitResource, repo, model, state);
+ }
+ measurementUnits.add(measurementUnit);
+ }
+ measurementUnits.forEach(unit->feature.addRecommendedMeasurementUnit(unit));
+ // import modifier TODO: create entire vocabulary if it cannot be found
+ Set<TermVocabulary<DefinedTerm>> modifierVocs = new HashSet<>();
+ List<Statement> modifierEnumStatements = termResource.listProperties(OwlUtil.propFeatureHasRecommendedModifierEnumeration).toList();
+ for (Statement statement : modifierEnumStatements) {
+ Resource modifierEnumResource = model.createResource(statement.getObject().toString());
+ TermVocabulary modifierVoc = findVocabulary(modifierEnumResource, repo, model, state);
+ if(modifierVoc!=null){
+ modifierVocs.add(modifierVoc);
+ }
+ }
+ modifierVocs.forEach(modiferVoc->feature.addRecommendedModifierEnumeration(modiferVoc));
+ // import statistical measures
+ Set<StatisticalMeasure> statisticalMeasures = new HashSet<>();
+ List<Statement> statisticalMeasureStatements = termResource.listProperties(OwlUtil.propFeatureHasRecommendedStatisticalMeasure).toList();
+ for (Statement statement : statisticalMeasureStatements) {
+ Resource statisticalMeasureResource = model.createResource(statement.getObject().toString());
+ StatisticalMeasure statisticalMeasure = findTerm(StatisticalMeasure.class, statisticalMeasureResource, repo, model, state);
+ if(statisticalMeasure==null){
+ statisticalMeasure = StatisticalMeasure.NewInstance();
+ addTermProperties(statisticalMeasure, statisticalMeasureResource, repo, model, state);
+ }
+ statisticalMeasures.add(statisticalMeasure);
+ }
+ statisticalMeasures.forEach(statisticalMeasure->feature.addRecommendedStatisticalMeasure(statisticalMeasure));
+ // import categorical enums TODO: create entire vocabulary if it cannot be found
+ Set<TermVocabulary<State>> stateVocs = new HashSet<>();
+ List<Statement> stateVocStatements = termResource.listProperties(OwlUtil.propFeatureHasSupportedCategoricalEnumeration).toList();
+ for (Statement statement : stateVocStatements) {
+ Resource stateVocResource = model.createResource(statement.getObject().toString());
+ TermVocabulary stateVoc = findVocabulary(stateVocResource, repo, model, state);
+ if(stateVoc!=null){
+ stateVocs.add(stateVoc);
+ }
+ }
+ stateVocs.forEach(stateVoc->feature.addSupportedCategoricalEnumeration(stateVoc));
+ }
+
+ private static void addCharacterProperties(Character character, Resource termResource, ICdmRepository repo, Model model, StructureTreeOwlImportState state){
+ addFeatureProperties(character, termResource, repo, model, state);
+ // TODO import/export of complete term tree of structures and properties belonging to a character is necessary
+ // import structure
+ Statement structureStatement = termResource.getProperty(OwlUtil.propCharacterHasStructure);
+ Resource structureResource = model.createResource(structureStatement.getObject().toString());
+ TermNode structureNode = findNode(structureResource, repo, model, state);
+ if(structureNode!=null){
+ character.setStructure(structureNode);
+ }
+ // import property
+ Statement propertyStatement = termResource.getProperty(OwlUtil.propCharacterHasProperty);
+ Resource propertyResource = model.createResource(propertyStatement.getObject().toString());
+ TermNode propertyNode = findNode(propertyResource, repo, model, state);
+ if(propertyNode!=null){
+ character.setProperty(propertyNode);
+ }
+ // import structure modifier
+ if(termResource.hasProperty(OwlUtil.propCharacterHasStructureModfier)){
+ Statement structureModifierStatement = termResource.getProperty(OwlUtil.propCharacterHasStructureModfier);
+ Resource structureModifierResource = model.createResource(structureModifierStatement.getObject().toString());
+ DefinedTerm structureModifier = findTerm(DefinedTerm.class, structureModifierResource, repo, model, state);
+ character.setStructureModifier(structureModifier);
+ }
+ }
+
+ private static void addTermProperties(DefinedTermBase term, Resource termResource, ICdmRepository repo, Model model, StructureTreeOwlImportState state){
+ term.setUuid(UUID.fromString(termResource.getProperty(OwlUtil.propUuid).getString()));
+
+ // term URI
+ String uriString = termResource.hasProperty(OwlUtil.propUri)?termResource.getProperty(OwlUtil.propUri).getString():null;
+ if(CdmUtils.isNotBlank(uriString)){
+ term.setUri(URI.create(uriString));
+ }
+ // symbol
+ String symbolString = termResource.hasProperty(OwlUtil.propTermSymbol)?termResource.getProperty(OwlUtil.propTermSymbol).getString():null;
+ if(CdmUtils.isNotBlank(symbolString)){
+ term.setSymbol(symbolString);
+ }
+ // symbol2
+ String symbol2String = termResource.hasProperty(OwlUtil.propTermSymbol2)?termResource.getProperty(OwlUtil.propTermSymbol2).getString():null;
+ if(CdmUtils.isNotBlank(symbol2String)){
+ term.setSymbol2(symbol2String);
+ }
+ // idInVocabulary
+ String idInVocabularyString = termResource.hasProperty(OwlUtil.propTermIdInVocabulary)?termResource.getProperty(OwlUtil.propTermIdInVocabulary).getString():null;
+ if(CdmUtils.isNotBlank(idInVocabularyString)){
+ term.setIdInVocabulary(idInVocabularyString);
+ }
+
+ // import representations
+ Set<Representation> representations = new HashSet<>();
+ termResource.listProperties(OwlUtil.propHasRepresentation).forEachRemaining(r->representations.add(OwlImportUtil.createRepresentation(repo, r, model)));
+ if(representations.isEmpty()){
+ logger.error("No representations found for term: "+termResource.getProperty(OwlUtil.propUuid));
+ }
+ representations.forEach(rep->term.addRepresentation(rep));
+
+ // import sources
+ Set<IdentifiableSource> sources = new HashSet<>();
+ termResource.listProperties(OwlUtil.propTermHasSource).forEachRemaining(sourceStatement->sources.add(OwlImportUtil.createSource(sourceStatement, repo, model)));
+ sources.forEach(source->term.addSource(source));
+
+ // add import source
+ IdentifiableSource importSource = IdentifiableSource.NewDataImportInstance(termResource.getURI());
+ importSource.setCitation(state.getConfig().getSourceReference());
+ term.addSource(importSource);
+ }
+
+ private static <T extends DefinedTermBase> T findTerm(Class<T> clazz, Resource termResource, ICdmRepository repo, Model model, StructureTreeOwlImportState state){
+ UUID termUuid = UUID.fromString(termResource.getProperty(OwlUtil.propUuid).getString());
+ List<T> terms = repo.getTermService().find(clazz, Collections.singleton(termUuid));
+ if(!terms.isEmpty()){
+ return terms.iterator().next();
+ }
+ return null;
+ }
+
+ private static TermVocabulary findVocabulary(Resource termResource, ICdmRepository repo, Model model, StructureTreeOwlImportState state){
+ UUID termUuid = UUID.fromString(termResource.getProperty(OwlUtil.propUuid).getString());
+ return repo.getVocabularyService().find(termUuid);
+ }
+
+ private static TermNode findNode(Resource termResource, ICdmRepository repo, Model model, StructureTreeOwlImportState state){
+ UUID uuid = UUID.fromString(termResource.getProperty(OwlUtil.propUuid).getString());
+ return repo.getFeatureNodeService().find(uuid);
+ }
+
+ private static Reference findReference(Resource resource, ICdmRepository repo){
+ UUID uuid = UUID.fromString(resource.getProperty(OwlUtil.propUuid).getString());
+ return repo.getReferenceService().find(uuid);
+ }
+
+ static Media findMedia(Resource resource, ICdmRepository repo){
+ UUID uuid = UUID.fromString(resource.getProperty(OwlUtil.propUuid).getString());
+ return repo.getMediaService().find(uuid);
+ }
+
+ static Feature createFeature(Resource termResource, ICdmRepository repo, Model model, StructureTreeOwlImportState state){
+ Feature feature = findTerm(Feature.class, termResource, repo, model, state);
+ if(feature==null){
+ feature = Feature.NewInstance();
+ addFeatureProperties(feature, termResource, repo, model, state);
+ }
+ return feature;
+ }
+
+ private static Character createCharacter(Resource termResource, ICdmRepository repo, Model model, StructureTreeOwlImportState state){
+ Character character = findTerm(Character.class, termResource, repo, model, state);
+ if(character==null){
+ character = Character.NewInstance();
+ addCharacterProperties(character, termResource, repo, model, state);
+ }
+ return character;
+ }
+
+ static DefinedTermBase createTerm(Resource termResource, ICdmRepository repo, Model model, StructureTreeOwlImportState state){
+ TermType termType = TermType.getByKey(termResource.getProperty(OwlUtil.propType).getString());
+ DefinedTermBase term = null;
+ // create new term
+ if(termType.equals(TermType.Feature)){
+ term = createFeature(termResource, repo, model, state);
+ }
+ else if(termType.equals(TermType.Character)){
+ term = createCharacter(termResource, repo, model, state);
+ }
+ else{
+ term = DefinedTerm.NewInstance(termType);
+ }
+ addTermProperties(term, termResource, repo, model, state);
+ return term;
+ }
+
+ static IdentifiableSource createSource(Statement sourceStatement, ICdmRepository repo, Model model) {
+ Resource sourceResource = model.createResource(sourceStatement.getObject().toString());
+
+ String typeString = sourceResource.getProperty(OwlUtil.propSourceType).getString();
+ IdentifiableSource source = IdentifiableSource.NewInstance(OriginalSourceType.getByKey(typeString));
+
+ if(sourceResource.hasProperty(OwlUtil.propSourceIdInSource)){
+ String idInSource = sourceResource.getProperty(OwlUtil.propSourceIdInSource).getString();
+ source.setIdInSource(idInSource);
+ }
+
+ // import citation
+ List<Statement> citationStatements = sourceResource.listProperties(OwlUtil.propSourceHasCitation).toList();
+ if(citationStatements.size()>1){
+ logger.error("More than one citations found for source. Choosing one arbitrarily. - "+sourceResource.toString());
+ }
+ if(!citationStatements.isEmpty()){
+ Statement citationStatement = citationStatements.iterator().next();
+ Resource citationResource = model.createResource(citationStatement.getObject().toString());
+ Reference reference = findReference(citationResource, repo);
+ if(reference==null){
+ reference = createReference(citationResource, model);
+ }
+ source.setCitation(reference);
+ }
+ return source;
+ }
+
+ static Reference createReference(Resource citationResource, Model model){
+ String titleString = citationResource.getProperty(OwlUtil.propReferenceTitle).getString();
+ Reference citation = ReferenceFactory.newGeneric();
+ citation.setTitle(titleString);
+ return citation;
+ }
+
+ static TermVocabulary createVocabulary(Resource vocabularyResource, ICdmRepository repo, Model model, StructureTreeOwlImportState state){
+ TermType termType = TermType.getByKey(vocabularyResource.getProperty(OwlUtil.propType).getString());
+ // create new vocabulary
+ TermVocabulary vocabulary = TermVocabulary.NewInstance(termType);
+ vocabulary.setUuid(UUID.fromString(vocabularyResource.getProperty(OwlUtil.propUuid).getString()));
+
+ // voc URI
+ String vocUriString = vocabularyResource.hasProperty(OwlUtil.propUri)?vocabularyResource.getProperty(OwlUtil.propUri).getString():null;
+ if(CdmUtils.isNotBlank(vocUriString)){
+ vocabulary.setUri(URI.create(vocUriString));
+ }
+
+ // voc representations
+ Set<Representation> vocRepresentations = new HashSet<>();
+ vocabularyResource.listProperties(OwlUtil.propHasRepresentation).forEachRemaining(r->vocRepresentations.add(OwlImportUtil.createRepresentation(repo, r, model)));
+ if(vocRepresentations.isEmpty()){
+ logger.error("No representations found for vocabulary: "+vocabularyResource.getProperty(OwlUtil.propUuid));
+ }
+ vocRepresentations.forEach(rep->vocabulary.addRepresentation(rep));
+
+ IdentifiableSource importSource = IdentifiableSource.NewDataImportInstance(vocabularyResource.getURI());
+ importSource.setCitation(state.getConfig().getSourceReference());
+ vocabulary.addSource(importSource);
+
+
+ return vocabulary;
+ }
+
+ static Media createMedia(Resource mediaResource, StructureTreeOwlImportState state){
+ URI mediaUri = URI.create(mediaResource.getProperty(OwlUtil.propMediaUri).getString());
+ // create new media
+ Media media = Media.NewInstance(mediaUri, null, null, null);
+ media.setUuid(UUID.fromString(mediaResource.getProperty(OwlUtil.propUuid).getString()));
+
+ if(mediaResource.hasProperty(OwlUtil.propMediaTitle)){
+ // TODO: support multiple language titles
+ media.putTitle(Language.DEFAULT(), mediaResource.getProperty(OwlUtil.propMediaTitle).getString());
+ }
+
+ IdentifiableSource importSource = IdentifiableSource.NewDataImportInstance(mediaResource.getURI());
+ importSource.setCitation(state.getConfig().getSourceReference());
+ media.addSource(importSource);
+
+ return media;
+ }
+
+ static Representation createRepresentation(ICdmRepository repo, Statement repr, Model model) {
+ Resource repsentationResource = model.createResource(repr.getObject().toString());
+
+ String languageLabel = repsentationResource.getProperty(OwlUtil.propLanguage).getString();
+ UUID languageUuid = UUID.fromString(repsentationResource.getProperty(OwlUtil.propLanguageUuid).getString());
+ Language language = Language.getLanguageFromUuid(languageUuid);
+ if(language==null){
+ language = repo.getTermService().getLanguageByLabel(languageLabel);
+ }
+ if(language==null){
+ language = Language.getDefaultLanguage();
+ }
+
+ String abbreviatedLabel = repsentationResource.hasProperty(OwlUtil.propLabelAbbrev)?repsentationResource.getProperty(OwlUtil.propLabelAbbrev).getString():null;
+ String plural = repsentationResource.hasProperty(OwlUtil.propLabelPlural)?repsentationResource.getProperty(OwlUtil.propLabelPlural).getString():null;
+ String label = repsentationResource.getProperty(OwlUtil.propLabel).getString();
+ String description = repsentationResource.hasProperty(OwlUtil.propDescription)?repsentationResource.getProperty(OwlUtil.propDescription).getString():null;
+ Representation representation = Representation.NewInstance(description, label, abbreviatedLabel, language);
+ representation.setPlural(plural);
+
+ return representation;
+ }
+
+}
import eu.etaxonomy.cdm.model.description.Feature;
import eu.etaxonomy.cdm.model.term.DefinedTermBase;
import eu.etaxonomy.cdm.model.term.TermTree;
-import eu.etaxonomy.cdm.model.term.TermTreeNode;
+import eu.etaxonomy.cdm.model.term.TermNode;
import eu.etaxonomy.cdm.model.term.TermType;
import eu.etaxonomy.cdm.model.term.TermVocabulary;
}
}
- private <T extends DefinedTermBase> void createNode(TermTreeNode<T> parent, Statement nodeStatement, String treeLabel, Model model, StructureTreeOwlImportState state) {
+ private <T extends DefinedTermBase> void createNode(TermNode<T> parent, Statement nodeStatement, String treeLabel, Model model, StructureTreeOwlImportState state) {
if(state.getConfig().getProgressMonitor().isCanceled()){
return;
}
getVocabularyService().saveOrUpdate(vocabulary);
- TermTreeNode<?> childNode = parent.addChild(term);
+ TermNode<?> childNode = parent.addChild(term);
state.getConfig().getProgressMonitor().worked(1);
import eu.etaxonomy.cdm.model.term.Representation;
import eu.etaxonomy.cdm.model.term.TermBase;
import eu.etaxonomy.cdm.model.term.TermTree;
-import eu.etaxonomy.cdm.model.term.TermTreeNode;
+import eu.etaxonomy.cdm.model.term.TermNode;
import eu.etaxonomy.cdm.model.term.TermVocabulary;
import eu.etaxonomy.cdm.persistence.dto.TermDto;
.addProperty(OwlUtil.propType, featureTree.getTermType().getKey())
;
- TermTreeNode rootNode = featureTree.getRoot();
+ TermNode rootNode = featureTree.getRoot();
Resource resourceRootNode = OwlExportUtil.createNodeResource(rootNode, false, repo, state);
featureTreeResource.addProperty(OwlUtil.propHasRootNode, resourceRootNode);
return featureTreeResource;
}
- private static void addChildNode(TermTreeNode parentNode, Resource parentResourceNode, ICdmRepository repo, StructureTreeOwlExportState state){
- List<TermTreeNode> childNodes = parentNode.getChildNodes();
- for (TermTreeNode child : childNodes) {
+ private static void addChildNode(TermNode parentNode, Resource parentResourceNode, ICdmRepository repo, StructureTreeOwlExportState state){
+ List<TermNode> childNodes = parentNode.getChildNodes();
+ for (TermNode child : childNodes) {
// create node resource with term
Resource nodeResource = OwlExportUtil.createNodeResource(child, false, repo, state);
}
}
- static Resource createNodeResource(TermTreeNode<Feature> node, boolean initFeatureTree, ICdmRepository repo, StructureTreeOwlExportState state) {
+ static Resource createNodeResource(TermNode<Feature> node, boolean initFeatureTree, ICdmRepository repo, StructureTreeOwlExportState state) {
if(initFeatureTree){
createFeatureTreeResource(node.getGraph(), repo, state);
return getNodeResource(node, state);
return state.getModel().createResource(OwlUtil.RESOURCE_MEDIA+media.getUuid().toString());
}
- private static Resource getNodeResource(TermTreeNode node, StructureTreeOwlExportState state) {
+ private static Resource getNodeResource(TermNode node, StructureTreeOwlExportState state) {
return state.getModel().createResource(OwlUtil.RESOURCE_NODE + node.getUuid().toString());
}
import eu.etaxonomy.cdm.io.common.mapping.out.IExportTransformer;
import eu.etaxonomy.cdm.model.term.DefinedTermBase;
import eu.etaxonomy.cdm.model.term.TermTree;
-import eu.etaxonomy.cdm.model.term.TermTreeNode;
+import eu.etaxonomy.cdm.model.term.TermNode;
/**
*
TermTree featureTree = state.getConfig().getFeatureTree();
featureTree = getFeatureTreeService().load(featureTree.getUuid());
- TermTreeNode rootNode = featureTree.getRoot();
+ TermNode rootNode = featureTree.getRoot();
try {
exportStream = generateDocx4JDocument(rootNode);
return;
}
- private ByteArrayOutputStream generateDocx4JDocument(TermTreeNode rootNode) throws Exception {
+ private ByteArrayOutputStream generateDocx4JDocument(TermNode rootNode) throws Exception {
InputStream resourceAsStream = this.getClass().getClassLoader().getResourceAsStream("eu/etaxonomy/cdm/io/word/out/template.docx");
WordprocessingMLPackage wordPackage = WordprocessingMLPackage.load(resourceAsStream);
MainDocumentPart mainDocumentPart = wordPackage.getMainDocumentPart();
// return new JAXBElement( new QName(Namespaces.NS_WORD12, "fldChar"), org.docx4j.wml.FldChar.class, fldchar);
// }
- private void addChildNode(TermTreeNode<?> node, MainDocumentPart mainDocumentPart, int indent) throws Exception{
+ private void addChildNode(TermNode<?> node, MainDocumentPart mainDocumentPart, int indent) throws Exception{
String styleId = "Heading"+indent;
- for (TermTreeNode childNode : node.getChildNodes()) {
+ for (TermNode childNode : node.getChildNodes()) {
DefinedTermBase term = childNode.getTerm();
mainDocumentPart.addStyledParagraphOfText(styleId, term.getLabel());
if(term.getDescription()!=null){
import eu.etaxonomy.cdm.model.taxon.TaxonNode;\r
import eu.etaxonomy.cdm.model.term.DefinedTermBase;\r
import eu.etaxonomy.cdm.model.term.TermTree;\r
-import eu.etaxonomy.cdm.model.term.TermTreeNode;\r
+import eu.etaxonomy.cdm.model.term.TermNode;\r
import eu.etaxonomy.cdm.model.term.TermVocabulary;\r
\r
/**\r
List<TypeDesignationBase<?>> typeDesignations;
List<SpecimenOrObservationBase> occurrences;
List<TermTree> featureTrees;
- List<TermTreeNode> featureNodes;\r
+ List<TermNode> featureNodes;\r
List<Media> media;\r
List<LanguageStringBase> languageData;\r
List<TermVocabulary<DefinedTermBase>> termVocabularies;\r
import eu.etaxonomy.cdm.model.occurrence.Collection;\r
import eu.etaxonomy.cdm.model.reference.Reference;\r
import eu.etaxonomy.cdm.model.taxon.Taxon;\r
-import eu.etaxonomy.cdm.model.term.TermTreeNode;\r
+import eu.etaxonomy.cdm.model.term.TermNode;\r
\r
/**\r
* @author a.mueller\r
private UnmatchedLeads unmatchedLeads;\r
private boolean onlyNumberedTaxaExist; //attribute in <key>\r
\r
- private Set<TermTreeNode> featureNodesToSave = new HashSet<TermTreeNode>();\r
+ private Set<TermNode> featureNodesToSave = new HashSet<TermNode>();\r
\r
private Set<PolytomousKeyNode> polytomousKeyNodesToSave = new HashSet<>();\r
\r
* @see MarkupImportConfigurator#getNewState()\r
*/\r
protected void reset(){\r
- featureNodesToSave = new HashSet<TermTreeNode>();\r
+ featureNodesToSave = new HashSet<TermNode>();\r
polytomousKeyNodesToSave = new HashSet<PolytomousKeyNode>();\r
currentKey = null;\r
defaultLanguage = null;\r
this.unmatchedLeads = unmatchedKeys;\r
}\r
\r
- public void setFeatureNodesToSave(Set<TermTreeNode> featureNodesToSave) {\r
+ public void setFeatureNodesToSave(Set<TermNode> featureNodesToSave) {\r
this.featureNodesToSave = featureNodesToSave;\r
}\r
\r
- public Set<TermTreeNode> getFeatureNodesToSave() {\r
+ public Set<TermNode> getFeatureNodesToSave() {\r
return featureNodesToSave;\r
}\r
\r
import eu.etaxonomy.cdm.model.term.Representation;\r
import eu.etaxonomy.cdm.model.term.TermBase;\r
import eu.etaxonomy.cdm.model.term.TermTree;\r
-import eu.etaxonomy.cdm.model.term.TermTreeNode;\r
+import eu.etaxonomy.cdm.model.term.TermNode;\r
import eu.etaxonomy.cdm.model.term.TermType;\r
import eu.etaxonomy.cdm.model.term.TermVocabulary;\r
\r
private Map<String,String> citations = new HashMap<>();\r
private Map<String,String> defaultUnitPrefixes = new HashMap<>();\r
private Map<String,Person> editors = new HashMap<>();\r
- private Map<String,TermTreeNode<Feature>> featureNodes = new HashMap<>();\r
+ private Map<String,TermNode<Feature>> featureNodes = new HashMap<>();\r
private Map<String,Feature> features = new HashMap<>();\r
private Map<String,String> locations = new HashMap<>();\r
private Map<String,List<CdmBase>> mediaObject_ListCdmBase = new HashMap<>();\r
\r
TermTree featureTree = TermTree.NewInstance();\r
importRepresentation(elCharacterTree, sddNamespace, featureTree, "", cdmState);\r
- TermTreeNode<Feature> root = featureTree.getRoot();\r
+ TermNode<Feature> root = featureTree.getRoot();\r
List<Element> listeOfNodes = elCharacterTree.getChildren("Nodes", sddNamespace);\r
\r
//Nodes of CharacterTrees in SDD always refer to DescriptiveConcepts\r
* @param root\r
* @param elNodes\r
*/\r
- private void handleCharacterNodes(Namespace sddNamespace, TermTreeNode<Feature> root, Element elNodes) {\r
+ private void handleCharacterNodes(Namespace sddNamespace, TermNode<Feature> root, Element elNodes) {\r
List<Element> listNodes = elNodes.getChildren("Node", sddNamespace);\r
if (listNodes != null) {\r
for (Element elNode : listNodes){\r
String idN = elNode.getAttributeValue("id");\r
- TermTreeNode<Feature> fn = null;\r
+ TermNode<Feature> fn = null;\r
Feature dc = null;\r
if (idN!=null) {\r
// DescriptiveConcepts are used as nodes in CharacterTrees\r
if (elParent!=null){\r
String refP = elParent.getAttributeValue("ref");\r
if (refP!=null) {\r
- TermTreeNode<Feature> parent = featureNodes.get(refP);\r
+ TermNode<Feature> parent = featureNodes.get(refP);\r
if (parent==null){\r
// if no parent found or the reference is broken, add the node to the root of the tree\r
fn = (dc==null)?root.addChild():root.addChild(dc);\r
Element elParent = elCharNode.getChild("Parent", sddNamespace);\r
Element elCharacter = elCharNode.getChild("Character", sddNamespace);\r
Element elDependencyRules = elCharNode.getChild("DependencyRules", sddNamespace);\r
- TermTreeNode<Feature> fn = null;\r
+ TermNode<Feature> fn = null;\r
\r
if (elParent!=null){\r
String refP = elParent.getAttributeValue("ref");\r
if ((refP!=null)&&(!refP.equals(""))) {\r
- TermTreeNode<Feature> parent = featureNodes.get(refP);\r
+ TermNode<Feature> parent = featureNodes.get(refP);\r
if (parent==null){\r
parent = root; // if no parent found or the reference is broken, add the node to the root of the tree\r
}\r
import eu.etaxonomy.cdm.model.term.DefinedTermBase;\r
import eu.etaxonomy.cdm.model.term.Representation;\r
import eu.etaxonomy.cdm.model.term.TermTree;\r
-import eu.etaxonomy.cdm.model.term.TermTreeNode;\r
+import eu.etaxonomy.cdm.model.term.TermNode;\r
import eu.etaxonomy.cdm.model.term.TermVocabulary;\r
\r
/**\r
\r
@XmlElementWrapper(name = "FeatureData")\r
@XmlElements({
- @XmlElement(name = "FeatureNode", namespace = "http://etaxonomy.eu/cdm/model/description/1.0", type = TermTreeNode.class),
+ @XmlElement(name = "FeatureNode", namespace = "http://etaxonomy.eu/cdm/model/description/1.0", type = TermNode.class),
@XmlElement(name = "FeatureTree", namespace = "http://etaxonomy.eu/cdm/model/description/1.0", type = TermTree.class)
})\r
// protected List<VersionableEntity> featureData;\r
import eu.etaxonomy.cdm.model.term.Representation;\r
import eu.etaxonomy.cdm.model.term.TermBase;\r
import eu.etaxonomy.cdm.model.term.TermTree;\r
-import eu.etaxonomy.cdm.model.term.TermTreeNode;\r
+import eu.etaxonomy.cdm.model.term.TermNode;\r
import eu.etaxonomy.cdm.model.term.TermVocabulary;\r
\r
/**\r
private final Map<Person, String> agents = new HashMap<>();\r
private final Map<TaxonName, String> taxonNames = new HashMap<>();\r
private final Map<Feature, String> characters = new HashMap<>();\r
- private final Map<TermTreeNode, String> featureNodes = new HashMap<>();\r
+ private final Map<TermNode, String> featureNodes = new HashMap<>();\r
private final Map<Feature, String> descriptiveConcepts = new HashMap<>();\r
private final Map<TaxonDescription, String> codedDescriptions = new HashMap<>();\r
private final Map<Media, String> medias = new HashMap<>();\r
elChartrees.appendChild(elChartree);\r
ElementImpl elNodes = new ElementImpl(document, NODES);\r
elChartree.appendChild(elNodes);\r
- List<TermTreeNode> roots = ft.getRootChildren();\r
- for (Iterator<TermTreeNode> fn = roots.iterator(); fn\r
+ List<TermNode> roots = ft.getRootChildren();\r
+ for (Iterator<TermNode> fn = roots.iterator(); fn\r
.hasNext();) {\r
- TermTreeNode featureNode = fn.next();\r
+ TermNode featureNode = fn.next();\r
buildBranches(featureNode, elNodes, true);\r
}\r
}\r
}\r
}\r
\r
- public void buildBranches(TermTreeNode<Feature> parent, ElementImpl element,\r
+ public void buildBranches(TermNode<Feature> parent, ElementImpl element,\r
boolean isRoot) {\r
- List<TermTreeNode<Feature>> children = parent.getChildNodes();\r
+ List<TermNode<Feature>> children = parent.getChildNodes();\r
if (!parent.isLeaf()) {\r
ElementImpl elCharNode = new ElementImpl(document, NODE);\r
charnodeCount = buildReference(parent, featuretrees, ID,\r
elCharNode, "cn", charnodeCount);\r
- TermTreeNode grandparent = parent.getParent();\r
+ TermNode grandparent = parent.getParent();\r
if ((grandparent != null) && (!isRoot)) {\r
ElementImpl elParent = new ElementImpl(document, PARENT);\r
charnodeCount = buildReference(grandparent, featuretrees, REF,\r
REF, elDescriptiveConcept, "dc", descriptiveConceptCount);\r
elCharNode.appendChild(elDescriptiveConcept);\r
element.appendChild(elCharNode);\r
- for (Iterator<TermTreeNode<Feature>> ifn = children.iterator(); ifn.hasNext();) {\r
- TermTreeNode fn = ifn.next();\r
+ for (Iterator<TermNode<Feature>> ifn = children.iterator(); ifn.hasNext();) {\r
+ TermNode fn = ifn.next();\r
buildBranches(fn, element, false);\r
}\r
} else {\r
ElementImpl elCharNode = new ElementImpl(document, CHAR_NODE);\r
ElementImpl elParent = new ElementImpl(document, PARENT);\r
- TermTreeNode grandparent = parent.getParent();\r
+ TermNode grandparent = parent.getParent();\r
charnodeCount = buildReference(grandparent, featuretrees, REF,\r
elParent, "cn", charnodeCount);\r
charnodeCount = buildReference(parent, featuretrees, ID,\r
import eu.etaxonomy.cdm.model.taxon.TaxonBase;
import eu.etaxonomy.cdm.model.taxon.TaxonNode;
import eu.etaxonomy.cdm.model.term.TermTree;
-import eu.etaxonomy.cdm.model.term.TermTreeNode;
+import eu.etaxonomy.cdm.model.term.TermNode;
import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
import eu.etaxonomy.cdm.persistence.query.MatchMode;
import eu.etaxonomy.cdm.strategy.exceptions.UnknownCdmTypeException;
proibiospheretree.setUuid(proIbioTreeUUID);
}
- TermTreeNode root2 = proibiospheretree.getRoot();
+ TermNode root2 = proibiospheretree.getRoot();
if (root2 != null){
int nbChildren = root2.getChildCount()-1;
while (nbChildren>-1){
<xs:element name="Feature" type="description:Feature"/>
- <xs:element name="TermTreeNode" type="description:FeatureNode"/>
+ <xs:element name="TermNode" type="description:FeatureNode"/>
<xs:element name="FeatureTree" type="description:FeatureTree"/>
import eu.etaxonomy.cdm.model.term.DefinedTermBase;
import eu.etaxonomy.cdm.model.term.Representation;
import eu.etaxonomy.cdm.model.term.TermTree;
-import eu.etaxonomy.cdm.model.term.TermTreeNode;
+import eu.etaxonomy.cdm.model.term.TermNode;
import eu.etaxonomy.cdm.model.term.TermType;
import eu.etaxonomy.cdm.model.term.TermVocabulary;
import eu.etaxonomy.cdm.persistence.dto.TermDto;
List rootChildren = tree.getRootChildren();
assertEquals("Wrong number of root children", 1, rootChildren.size());
Object entirePlant = rootChildren.iterator().next();
- assertTrue("Root is no feature node", entirePlant instanceof TermTreeNode);
- assertEquals("Root node has wrong term type", TermType.Structure, ((TermTreeNode)entirePlant).getTermType());
- TermTreeNode<DefinedTerm> entirePlantNode = (TermTreeNode<DefinedTerm>) entirePlant;
- List<TermTreeNode<DefinedTerm>> childNodes = entirePlantNode.getChildNodes();
+ assertTrue("Root is no feature node", entirePlant instanceof TermNode);
+ assertEquals("Root node has wrong term type", TermType.Structure, ((TermNode)entirePlant).getTermType());
+ TermNode<DefinedTerm> entirePlantNode = (TermNode<DefinedTerm>) entirePlant;
+ List<TermNode<DefinedTerm>> childNodes = entirePlantNode.getChildNodes();
assertEquals("Wrong number of children", 2, childNodes.size());
String inflorescenceLabel = "inflorescence";
DefinedTerm inflorescence = records.iterator().next();
assertEquals(inflorescenceLabel, inflorescence.getLabel(Language.ENGLISH()));
- for (TermTreeNode<DefinedTerm> featureNode : childNodes) {
+ for (TermNode<DefinedTerm> featureNode : childNodes) {
assertTrue("Child node not found. Found node with term: "+featureNode.getTerm().getLabel(),
featureNode.getTerm().getUuid().equals(inflorescence.getUuid())
|| featureNode.getTerm().getLabel(Language.ENGLISH()).equals("Flower"));
import eu.etaxonomy.cdm.model.common.CdmBase;
import eu.etaxonomy.cdm.model.description.Feature;
import eu.etaxonomy.cdm.model.term.TermTree;
-import eu.etaxonomy.cdm.model.term.TermTreeNode;
+import eu.etaxonomy.cdm.model.term.TermNode;
import eu.etaxonomy.cdm.model.term.TermType;
import eu.etaxonomy.cdm.model.term.TermVocabulary;
import eu.etaxonomy.cdm.test.integration.CdmTransactionalIntegrationTest;
Feature featureA = Feature.NewInstance("A", "A", "A");
voc.addTerm(featureA);
- TermTreeNode<Feature> nodeA = tree.getRoot().addChild(featureA);
+ TermNode<Feature> nodeA = tree.getRoot().addChild(featureA);
Feature featureA1 = Feature.NewInstance("A1", "A1", "A1");
voc.addTerm(featureA1);
- TermTreeNode<Feature> nodeA1 = nodeA.addChild(featureA1);
+ TermNode<Feature> nodeA1 = nodeA.addChild(featureA1);
Feature featureA2 = Feature.NewInstance("A2", "A2", "A2");
voc.addTerm(featureA2);
- TermTreeNode<Feature> nodeA2 = nodeA.addChild(featureA2);
+ TermNode<Feature> nodeA2 = nodeA.addChild(featureA2);
Feature featureB = Feature.NewInstance("B", "B", "B");
voc.addTerm(featureB);
- TermTreeNode<Feature> nodeB = tree.getRoot().addChild(featureB);
+ TermNode<Feature> nodeB = tree.getRoot().addChild(featureB);
Feature featureB1 = Feature.NewInstance("B", "B1", "B1");
voc.addTerm(featureB1);
- TermTreeNode<Feature> nodeB1 = nodeB.addChild(featureB1);
+ TermNode<Feature> nodeB1 = nodeB.addChild(featureB1);
Feature featureC = Feature.NewInstance("C", "C", "C");
voc.addTerm(featureC);
- TermTreeNode<Feature> nodeC = tree.getRoot().addChild(featureC);
+ TermNode<Feature> nodeC = tree.getRoot().addChild(featureC);
featureTreeService.save(tree);
return Collections.singletonList(tree.getUuid());
<TAXONRELATIONSHIP_MARKER_AUD/>
<TERMRELATION/>
<TERMRELATION_AUD/>
- <TERMTREENODE_DEFINEDTERMBASE_INAPPLICABLEIF/>
- <TERMTREENODE_DEFINEDTERMBASE_INAPPLICABLEIF_AUD/>
- <TERMTREENODE_DEFINEDTERMBASE_ONLYAPPLICABLE/>
- <TERMTREENODE_DEFINEDTERMBASE_ONLYAPPLICABLE_AUD/>
+ <TERMNODE_DEFINEDTERMBASE_INAPPLICABLEIF/>
+ <TERMNODE_DEFINEDTERMBASE_INAPPLICABLEIF_AUD/>
+ <TERMNODE_DEFINEDTERMBASE_ONLYAPPLICABLE/>
+ <TERMNODE_DEFINEDTERMBASE_ONLYAPPLICABLE_AUD/>
<TERMCOLLECTION_ANNOTATION/>
<TERMCOLLECTION_ANNOTATION_AUD/>
<TERMCOLLECTION_CREDIT/>
<TAXONRELATIONSHIP_MARKER_AUD/>
<TERMRELATION/>
<TERMRELATION_AUD/>
-<TERMTREENODE_DEFINEDTERMBASE_INAPPLICABLEIF/>
-<TERMTREENODE_DEFINEDTERMBASE_INAPPLICABLEIF_AUD/>
-<TERMTREENODE_DEFINEDTERMBASE_ONLYAPPLICABLE/>
-<TERMTREENODE_DEFINEDTERMBASE_ONLYAPPLICABLE_AUD/>
+<TERMNODE_DEFINEDTERMBASE_INAPPLICABLEIF/>
+<TERMNODE_DEFINEDTERMBASE_INAPPLICABLEIF_AUD/>
+<TERMNODE_DEFINEDTERMBASE_ONLYAPPLICABLE/>
+<TERMNODE_DEFINEDTERMBASE_ONLYAPPLICABLE_AUD/>
<TERMCOLLECTION />
<TERMCOLLECTION_AUD />
<TERMCOLLECTION_REPRESENTATION />
import java.util.regex.Pattern;
import eu.etaxonomy.cdm.model.taxon.TaxonNode;
-import eu.etaxonomy.cdm.model.term.TermTreeNode;
+import eu.etaxonomy.cdm.model.term.TermNode;
/**
- * A class to handle tree indexes as used in {@link TaxonNode}, {@link TermTreeNode}
+ * A class to handle tree indexes as used in {@link TaxonNode}, {@link TermNode}
* etc.<BR>
* Might be come a hibernate user type in future.
*
import eu.etaxonomy.cdm.model.common.Language;
import eu.etaxonomy.cdm.model.term.DefinedTerm;
-import eu.etaxonomy.cdm.model.term.TermTreeNode;
+import eu.etaxonomy.cdm.model.term.TermNode;
import eu.etaxonomy.cdm.model.term.TermType;
/**
@ManyToOne(fetch = FetchType.LAZY)
@IndexedEmbedded
// @Cascade({CascadeType.SAVE_UPDATE,CascadeType.MERGE})
- private TermTreeNode structure;
+ private TermNode structure;
//#8120
@XmlElement(name = "StructureModifier")
@ManyToOne(fetch = FetchType.LAZY)
@IndexedEmbedded
// @Cascade({CascadeType.SAVE_UPDATE,CascadeType.MERGE})
- private TermTreeNode property;
+ private TermNode property;
//#8120
/**
* @param property The property feature node for this character
* @see #Feature()
*/
- public static Character NewInstance(TermTreeNode structure, TermTreeNode property){
+ public static Character NewInstance(TermNode structure, TermNode property){
return new Character(structure, property, null, null, null);
}
* to be created
* @see #Feature()
*/
- public static Character NewInstance(TermTreeNode structure, TermTreeNode property, String term, String label, String labelAbbrev){
+ public static Character NewInstance(TermNode structure, TermNode property, String term, String label, String labelAbbrev){
return new Character(structure, property, term, label, labelAbbrev);
}
* to be created
* @see #Feature()
*/
- protected Character(TermTreeNode structure, TermTreeNode property, String term, String label, String labelAbbrev) {
+ protected Character(TermNode structure, TermNode property, String term, String label, String labelAbbrev) {
super(term, label, labelAbbrev);
this.setTermType(TermType.Character);
this.structure = structure;
// ****************** GETTER / SETTER *********************************************/
- public TermTreeNode getStructure() {
+ public TermNode getStructure() {
return structure;
}
- public void setStructure(TermTreeNode structure) {
+ public void setStructure(TermNode structure) {
this.structure = structure;
}
- public TermTreeNode getProperty() {
+ public TermNode getProperty() {
return property;
}
- public void setProperty(TermTreeNode property) {
+ public void setProperty(TermNode property) {
this.property = property;
}
extends ITermGraph<TERM, REL> {
/**
- * Returns the (ordered) list of {@link TermTreeNode feature nodes} which are immediate
+ * Returns the (ordered) list of {@link TermNode feature nodes} which are immediate
* children of the root node of <i>this</i> term tree.
*/
- public abstract List<TermTreeNode<TERM>> getRootChildren();
+ public abstract List<TermNode<TERM>> getRootChildren();
public List<TERM> asTermList();
@Audited
public class OrderedTermVocabulary<T extends OrderedTermBase>
extends TermVocabulary<T>
- implements ITermGraph<T, TermTreeNode> {
+ implements ITermGraph<T, TermNode> {
private static final long serialVersionUID = 7871741306306371242L;
}
@Override
- public Set<TermTreeNode> getTermRelations() {
+ public Set<TermNode> getTermRelations() {
return super.termRelations();
}
/**
* @param termRelations
*/
// @Override //not yet public
- protected void setTermRelations(Set<TermTreeNode> termRelations) {
+ protected void setTermRelations(Set<TermNode> termRelations) {
super.termRelations(termRelations);
}
*/
@SuppressWarnings("serial")
@XmlAccessorType(XmlAccessType.FIELD)
-@XmlType(name = "TermTreeNode", propOrder = {
+@XmlType(name = "TermNode", propOrder = {
"parent",
"treeIndex",
"sortIndex",
"onlyApplicableIf",
"inapplicableIf"
})
-@XmlRootElement(name = "TermTreeNode")
+@XmlRootElement(name = "TermNode")
@Entity
@Audited
-public class TermTreeNode <T extends DefinedTermBase>
- extends TermRelationBase<T, TermTreeNode<T>, TermTree>
- implements ITreeNode<TermTreeNode<T>> {
+public class TermNode <T extends DefinedTermBase>
+ extends TermRelationBase<T, TermNode<T>, TermTree>
+ implements ITreeNode<TermNode<T>> {
- private static final Logger logger = Logger.getLogger(TermTreeNode.class);
+ private static final Logger logger = Logger.getLogger(TermNode.class);
@XmlElement(name = "Parent")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
- @ManyToOne(fetch = FetchType.LAZY, targetEntity=TermTreeNode.class)
+ @ManyToOne(fetch = FetchType.LAZY, targetEntity=TermNode.class)
@Cascade({CascadeType.SAVE_UPDATE,CascadeType.MERGE})
@JoinColumn(name="parent_id")
- private TermTreeNode<T> parent;
+ private TermNode<T> parent;
@XmlElement(name = "treeIndex")
//see https://dev.e-taxonomy.eu/trac/ticket/3722
@OrderColumn(name="sortIndex")
@OrderBy("sortIndex")
- @OneToMany(fetch = FetchType.LAZY, mappedBy="parent", targetEntity=TermTreeNode.class)
+ @OneToMany(fetch = FetchType.LAZY, mappedBy="parent", targetEntity=TermNode.class)
@Cascade({CascadeType.SAVE_UPDATE, CascadeType.MERGE})
- private List<TermTreeNode<T>> children = new ArrayList<>();
+ private List<TermNode<T>> children = new ArrayList<>();
//see https://dev.e-taxonomy.eu/trac/ticket/3722
private Integer sortIndex;
@XmlSchemaType(name="IDREF")
@ManyToMany(fetch = FetchType.LAZY)
// @Cascade({CascadeType.SAVE_UPDATE,CascadeType.MERGE}) remove cascade #5755
- @JoinTable(name="TermTreeNode_DefinedTermBase_OnlyApplicable")
+ @JoinTable(name="TermNode_DefinedTermBase_OnlyApplicable")
private final Set<State> onlyApplicableIf = new HashSet<>();
@XmlElementWrapper(name = "InapplicableIf")
@XmlSchemaType(name="IDREF")
@ManyToMany(fetch = FetchType.LAZY)
// @Cascade({CascadeType.SAVE_UPDATE,CascadeType.MERGE}) remove cascade #5755
- @JoinTable(name="TermTreeNode_DefinedTermBase_InapplicableIf")
+ @JoinTable(name="TermNode_DefinedTermBase_InapplicableIf")
private final Set<State> inapplicableIf = new HashSet<>();
// ***************************** FACTORY *********************************/
- //no factory methods should be provided as FeatureNodes should only
+ //no factory methods should be provided as TermNodes should only
//be created as children of their parent node (#8257)
//TODO needed?
@Deprecated
- protected TermTreeNode(){}
+ protected TermNode(){}
/**
* Class constructor: creates a new empty feature node instance.
*/
- protected TermTreeNode(TermType termType) {
+ protected TermNode(TermType termType) {
super(termType);
}
* @see #getChildNodes()
*/
@Override
- public TermTreeNode<T> getParent() {
+ public TermNode<T> getParent() {
return parent;
}
/**
* @param parent the feature node to be set as parent
* @see #getParent()
*/
- protected void setParent(TermTreeNode<T> parent) {
+ protected void setParent(TermNode<T> parent) {
this.parent = parent;
}
* <i>this</i> feature node.
*/
@Override
- public List<TermTreeNode<T>> getChildNodes() {
+ public List<TermNode<T>> getChildNodes() {
return children;
}
* @param child the feature node to be added
* @see #getChildNodes()
* @see #setChildren(List)
- * @see #addChild(TermTreeNode, int)
- * @see #removeChild(TermTreeNode)
+ * @see #addChild(TermNode, int)
+ * @see #removeChild(TermNode)
* @see #removeChild(int)
*/
- public void addChild(TermTreeNode<T> child){
+ public void addChild(TermNode<T> child){
addChild(child, children.size());
}
* @return the newly created child node
* @see #getChildNodes()
* @see #setChildren(List)
- * @see #removeChild(FeatureNode)
+ * @see #removeChild(TermNode)
* @see #removeChild(int)
*/
- public TermTreeNode<T> addChild(){
+ public TermNode<T> addChild(){
return addChild((T)null, children.size());
}
* @return the newly created child node
* @see #getChildNodes()
* @see #setChildren(List)
- * @see #removeChild(FeatureNode)
+ * @see #removeChild(TermNode)
* @see #removeChild(int)
*/
- public TermTreeNode<T> addChild(T term){
+ public TermNode<T> addChild(T term){
return addChild(term, children.size());
}
* @return the newly created child node
* @see #getChildNodes()
* @see #setChildren(List)
- * @see #removeChild(FeatureNode)
+ * @see #removeChild(TermNode)
* @see #removeChild(int)
*/
- public TermTreeNode<T> addChild(T term, int index){
- TermTreeNode<T> child = new TermTreeNode<>(getTermType());
+ public TermNode<T> addChild(T term, int index){
+ TermNode<T> child = new TermNode<>(getTermType());
if(term!=null){
child.setTerm(term);
}
checkTermType(child);
- List<TermTreeNode<T>> children = this.getChildNodes();
+ List<TermNode<T>> children = this.getChildNodes();
if (index < 0 || index > children.size() + 1){
throw new IndexOutOfBoundsException("Wrong index: " + index);
}
* should be added
* @see #getChildNodes()
* @see #setChildren(List)
- * @see #addChild(TermTreeNode)
- * @see #removeChild(TermTreeNode)
+ * @see #addChild(TermNode)
+ * @see #removeChild(TermNode)
* @see #removeChild(int)
*/
- public void addChild(TermTreeNode<T> child, int index){
+ public void addChild(TermNode<T> child, int index){
checkTermType(child);
- List<TermTreeNode<T>> children = this.getChildNodes();
+ List<TermNode<T>> children = this.getChildNodes();
if (index < 0 || index > children.size() + 1){
throw new IndexOutOfBoundsException("Wrong index: " + index);
}
*
* @param child the feature node which should be removed
* @see #getChildNodes()
- * @see #addChild(TermTreeNode, int)
- * @see #addChild(TermTreeNode)
+ * @see #addChild(TermNode, int)
+ * @see #addChild(TermNode)
* @see #removeChild(int)
*/
- public void removeChild(TermTreeNode<T> child){
+ public void removeChild(TermNode<T> child){
int index = children.indexOf(child);
if (index >= 0){
* @param index the integer indicating the position of the feature node to
* be removed
* @see #getChildNodes()
- * @see #addChild(TermTreeNode, int)
- * @see #addChild(TermTreeNode)
- * @see #removeChild(TermTreeNode)
+ * @see #addChild(TermNode, int)
+ * @see #addChild(TermNode)
+ * @see #removeChild(TermNode)
*/
public void removeChild(int index){
- TermTreeNode<T> child = children.get(index);
+ TermNode<T> child = children.get(index);
if (child != null){
children.remove(index);
child.setParent(null);
child.setGraph(null);
//TODO workaround (see sortIndex doc)
for(int i = 0; i < children.size(); i++){
- TermTreeNode<T> childAt = children.get(i);
+ TermNode<T> childAt = children.get(i);
childAt.setSortIndex(i);
}
child.setSortIndex(null);
*
* @param childIndex the integer indicating the position of the feature node
* @see #getChildNodes()
- * @see #addChild(TermTreeNode, int)
+ * @see #addChild(TermNode, int)
* @see #removeChild(int)
*/
- public TermTreeNode<T> getChildAt(int childIndex) {
+ public TermNode<T> getChildAt(int childIndex) {
return children.get(childIndex);
}
* If the list does not contain this node then -1 will be returned.
*
* @param node the feature node the position of which is being searched
- * @see #addChild(TermTreeNode, int)
+ * @see #addChild(TermNode, int)
* @see #removeChild(int)
*/
- public int getIndex(TermTreeNode<T> node) {
+ public int getIndex(TermNode<T> node) {
if (! children.contains(node)){
return -1;
}else{
/**
* Returns all terms that are contained in this node or a child node
*
-<<<<<<< HEAD:cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/term/TermTreeNode.java
* @param terms
-=======
- * @param features
->>>>>>> ref #6794 add TermRelation and rename FeatureNode -> TermTreeNode:cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/term/TermTreeNode.java
* @return
*/
@Transient
if(term != null){
terms.add(term);
}
- for(TermTreeNode<T> childNode : this.getChildNodes()){
+ for(TermNode<T> childNode : this.getChildNodes()){
terms.addAll(childNode.getDistinctTermsRecursive(terms));
}
return terms;
if(term != null){
terms.add(term);
}
- for(TermTreeNode<T> childNode : this.getChildNodes()){
+ for(TermNode<T> childNode : this.getChildNodes()){
terms.addAll(childNode.asTermListRecursive(terms));
}
return terms;
//*********************** CLONE ********************************************************/
/**
- * Clones <i>this</i> {@link TermTreeNode}. This is a shortcut that enables to create
+ * Clones <i>this</i> {@link TermNode}. This is a shortcut that enables to create
* a new instance that differs only slightly from <i>this</i> tree node by
* modifying only some of the attributes.
* The parent, the feature and the featureTree are the same as for the original feature node
*/
@Override
public Object clone() {
- TermTreeNode<T> result;
+ TermNode<T> result;
try {
- result = (TermTreeNode<T>)super.clone();
+ result = (TermNode<T>)super.clone();
result.children = new ArrayList<>();
return result;
}catch (CloneNotSupportedException e) {
}
}
- public TermTreeNode<T> cloneDescendants(){
- TermTreeNode<T> clone = (TermTreeNode<T>)this.clone();
- TermTreeNode<T> childClone;
+ public TermNode<T> cloneDescendants(){
+ TermNode<T> clone = (TermNode<T>)this.clone();
+ TermNode<T> childClone;
- for(TermTreeNode<T> childNode : this.getChildNodes()){
- childClone = (TermTreeNode<T>) childNode.clone();
- for (TermTreeNode<T> childChild:childNode.getChildNodes()){
+ for(TermNode<T> childNode : this.getChildNodes()){
+ childClone = (TermNode<T>) childNode.clone();
+ for (TermNode<T> childChild:childNode.getChildNodes()){
childClone.addChild(childChild.cloneDescendants());
}
clone.addChild(childClone);
import eu.etaxonomy.cdm.model.common.VersionableEntity;
/**
- * Common base class for {@link TermTreeNode} and {@link TermRelation}.
+ * Common base class for {@link TermNode} and {@link TermRelation}.
* @author a.mueller
* @since 06.03.2019
*/
})
@Entity
@Audited
-@Table(name="TermRelation", indexes = { @Index(name = "termTreeNodeTreeIndex", columnList = "treeIndex") }) //was feature NodeTreeIndex before
+@Table(name="TermRelation", indexes = { @Index(name = "termNodeTreeIndex", columnList = "treeIndex") }) //was feature NodeTreeIndex before
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
public abstract class TermRelationBase<TERM extends DefinedTermBase, REL extends TermRelationBase, GRAPH extends TermGraphBase>
extends VersionableEntity
* determination process and for systematical output arrangement of
* {@link DescriptionElementBase description elements} according to different goals
* but may also be used to define flat feature subsets for filtering purposes.<BR>
- * A feature tree is build on {@link TermTreeNode feature nodes}.
+ * A feature tree is build on {@link TermNode feature nodes}.
* <P>
* This class corresponds partially to ConceptTreeDefType according to the SDD
* schema.
//@Indexed(index = "eu.etaxonomy.cdm.model.term.TermTree")
@Audited
public class TermTree <T extends DefinedTermBase>
- extends TermGraphBase<T, TermTreeNode> {
+ extends TermGraphBase<T, TermNode> {
private static final long serialVersionUID = -6713834139003172735L;
private static final Logger logger = Logger.getLogger(TermTree.class);
//instead of representation. This may not be correct.
@XmlElement(name = "Root")
- @OneToOne(fetch = FetchType.LAZY, targetEntity=TermTreeNode.class)
+ @OneToOne(fetch = FetchType.LAZY, targetEntity=TermNode.class)
@Cascade({CascadeType.SAVE_UPDATE, CascadeType.MERGE})
- private TermTreeNode<T> root;
+ private TermNode<T> root;
//******************** FACTORY METHODS ******************************************/
* Creates a new feature tree instance with a {@link #getRoot() root node}
* the children of which are the feature nodes build on the base of the
* given list of {@link Feature features}. This corresponds to a flat feature tree.
- * For each feature within the list a new {@link TermTreeNode feature node} without
+ * For each feature within the list a new {@link TermNode feature node} without
* children nodes will be created.
*
* @param featureList the feature list
*/
public static TermTree<Feature> NewInstance(List<Feature> featureList){
TermTree<Feature> result = new TermTree<>(TermType.Feature);
- TermTreeNode<Feature> root = result.getRoot();
+ TermNode<Feature> root = result.getRoot();
for (Feature feature : featureList){
root.addChild(feature);
*/
protected TermTree(TermType termType) {
super(termType);
- root = new TermTreeNode<>(termType);
+ root = new TermNode<>(termType);
root.setGraph(this);
}
// ****************** GETTER / SETTER **********************************/
/**
- * Returns the topmost {@link TermTreeNode feature node} (root node) of <i>this</i>
+ * Returns the topmost {@link TermNode feature node} (root node) of <i>this</i>
* feature tree. The root node does not have any parent. Since feature nodes
* recursively point to their child nodes the complete feature tree is
* defined by its root node.
*/
- public TermTreeNode<T> getRoot() {
+ public TermNode<T> getRoot() {
return root;
}
}
/**
- * Returns the (ordered) list of {@link TermTreeNode feature nodes} which are immediate
+ * Returns the (ordered) list of {@link TermNode feature nodes} which are immediate
* children of the root node of <i>this</i> feature tree.
*/
@Transient
- public List<TermTreeNode<T>> getRootChildren(){
- List<TermTreeNode<T>> result = new ArrayList<>();
+ public List<TermNode<T>> getRootChildren(){
+ List<TermNode<T>> result = new ArrayList<>();
result.addAll(root.getChildNodes());
return result;
}
public List<T> asTermList() {
List<T> result = new ArrayList<>();
- for (TermTreeNode<T> node : getRootChildren()){
+ for (TermNode<T> node : getRootChildren()){
result.add(node.getTerm());
result.addAll(node.asTermListRecursive(result));
}
* Clones <i>this</i> {@link TermTree}. This is a shortcut that enables to create
* a new instance that differs only slightly from <i>this</i> tree by
* modifying only some of the attributes.
- * {@link TermTreeNode tree nodes} always belong only to one tree, so all
- * {@link TermTreeNode tree nodes} are cloned to build
+ * {@link TermNode tree nodes} always belong only to one tree, so all
+ * {@link TermNode tree nodes} are cloned to build
* the new {@link TermTree}
*
*
e.printStackTrace();
return null;
}
- TermTreeNode<T> rootClone = this.getRoot().cloneDescendants();
+ TermNode<T> rootClone = this.getRoot().cloneDescendants();
result.root = rootClone;
return result;
//@Indexed(index = "eu.etaxonomy.cdm.model.term.TermVocabulary")
@Audited
public class TermVocabulary<T extends DefinedTermBase>
- extends TermCollection<T,TermTreeNode> {
+ extends TermCollection<T,TermNode> {
private static final long serialVersionUID = 1925052321596648672L;
private static final Logger logger = Logger.getLogger(TermVocabulary.class);
import eu.etaxonomy.cdm.model.description.StatisticalMeasurementValue;
import eu.etaxonomy.cdm.model.description.TaxonDescription;
import eu.etaxonomy.cdm.model.term.TermTree;
-import eu.etaxonomy.cdm.model.term.TermTreeNode;
+import eu.etaxonomy.cdm.model.term.TermNode;
/**
* @author m.venin
*
* @param node
*/
- private void checkDependencies(TermTreeNode<Feature> node){
+ private void checkDependencies(TermNode<Feature> node){
if (node.getOnlyApplicableIf()!=null){
Set<State> addToOAI = node.getOnlyApplicableIf();
for (State state : addToOAI){
}
}
if (node.getChildNodes()!=null) {
- for (TermTreeNode fn : node.getChildNodes()){
+ for (TermNode fn : node.getChildNodes()){
checkDependencies(fn);
}
}
private static final Logger logger = Logger.getLogger(FeatureTreeTest.class);
private TermTree<Feature> testTree;
- private TermTreeNode<Feature> node1;
- private TermTreeNode<Feature> node2;
- private TermTreeNode<Feature> node3;
- private TermTreeNode<Feature> node4;
+ private TermNode<Feature> node1;
+ private TermNode<Feature> node2;
+ private TermNode<Feature> node3;
+ private TermNode<Feature> node4;
@BeforeClass
public static void setUpBeforeClass() {
// }
@Test
public void testAddChild(){
- TermTreeNode<Feature> node21 = node1.addChild(Feature.ANATOMY(), 1);
+ TermNode<Feature> node21 = node1.addChild(Feature.ANATOMY(), 1);
assertEquals(node1.getChildNodes().size(), 2);
assertEquals(node1.getChildNodes().get(1), node21);
assertEquals(node21.getParent(), node1);
}
@Test
public void testClone(){
- TermTreeNode<Feature> node21 = node1.addChild(Feature.ADDITIONAL_PUBLICATION(), 1);
+ TermNode<Feature> node21 = node1.addChild(Feature.ADDITIONAL_PUBLICATION(), 1);
TermTree<Feature> clone = (TermTree<Feature>) testTree.clone();
assertEquals (clone.getRoot().getTerm(), testTree.getRoot().getTerm());
assertNotSame(clone.getRoot(), testTree.getRoot());
- List<TermTreeNode<Feature>> children = clone.getRootChildren();
+ List<TermNode<Feature>> children = clone.getRootChildren();
assertEquals(children.get(0).getTerm(), node1.getTerm());
assertNotSame(children.get(0), node1);
import eu.etaxonomy.cdm.model.term.DefinedTerm;
import eu.etaxonomy.cdm.model.term.Representation;
import eu.etaxonomy.cdm.model.term.TermTree;
-import eu.etaxonomy.cdm.model.term.TermTreeNode;
+import eu.etaxonomy.cdm.model.term.TermNode;
import eu.etaxonomy.cdm.model.term.TermType;
import eu.etaxonomy.cdm.model.term.TermVocabulary;
import eu.etaxonomy.cdm.strategy.parser.TimePeriodParser;
//Feature Tree
TermTree<Feature> featureTree = TermTree.NewInstance();
// featureTree
- TermTreeNode<Feature> descriptionFeatureNode = featureTree.getRoot().addChild(Feature.DESCRIPTION());
- TermTreeNode<Feature> leaveLengthNode = descriptionFeatureNode.addChild(leaveLength);
+ TermNode<Feature> descriptionTermNode = featureTree.getRoot().addChild(Feature.DESCRIPTION());
+ TermNode<Feature> leaveLengthNode = descriptionTermNode.addChild(leaveLength);
handleIdentifiableEntity(featureTree);
State inapplicableState = State.NewInstance("inapplicableState", "inapplicableState", null);
// update tree index for feature node
//note: it could also be enough to only replace the first index entry by graph_id as only the graph_id changed
- String stepName = "Update TermTreeNode treeindex";
+ String stepName = "Update TermNode treeindex";
String tableName = "TermRelation";
String treeIdColumnName = "graph_id";
ISchemaUpdaterStep step = TreeIndexUpdater.NewInstance(stepName, tableName,
updateSupplement("RightsInfo", "rights_id", featureTreeId, maxIdTermVoc, datasource, monitor, caseType, result, false);
updateDescriptiveSystem(featureTreeId, maxIdTermVoc, datasource, monitor, caseType, result);
- updateTermTreeNode(featureTreeId, maxIdTermVoc, datasource, monitor, caseType, result);
+ updateTermNode(featureTreeId, maxIdTermVoc, datasource, monitor, caseType, result);
// xx treeIndex update;
* @param result
* @throws SQLException
*/
- private void updateTermTreeNode(Integer featureTreeId, int maxIdTermVoc, ICdmDataSource datasource,
+ private void updateTermNode(Integer featureTreeId, int maxIdTermVoc, ICdmDataSource datasource,
IProgressMonitor monitor, CaseType caseType, SchemaUpdateResult result) throws SQLException {
String update = "UPDATE @@TermRelation@@ "
+ " SET graph_id = " + maxIdTermVoc
//#6794 add DTYPE to TermRelation
stepName = "add DTYPE to TermRelation";
tableName = "TermRelation";
- step = ColumnAdder.NewDTYPEInstance(stepName, tableName, "TermTreeNode", INCLUDE_AUDIT) ;
+ step = ColumnAdder.NewDTYPEInstance(stepName, tableName, "TermNode", INCLUDE_AUDIT) ;
stepList.add(step);
//#6794 add root_id column to TermCollection
step = ColumnNameChanger.NewIntegerInstance(stepName, tableName, oldColumnName, newColumnName, INCLUDE_AUDIT);
stepList.add(step);
- //#6794 rename FeatureNode_DefinedTermBase_InapplicableIf to TermTreeNode_DefinedTermBase_InapplicableIf
- stepName = "rename FeatureNode_DefinedTermBase_InapplicableIf to TermTreeNode_DefinedTermBase_InapplicableIf";
+ //#6794 rename FeatureNode_DefinedTermBase_InapplicableIf to TermNode_DefinedTermBase_InapplicableIf
+ stepName = "rename FeatureNode_DefinedTermBase_InapplicableIf to TermNode_DefinedTermBase_InapplicableIf";
oldName = "FeatureNode_DefinedTermBase_InapplicableIf";
- newName = "TermTreeNode_DefinedTermBase_InapplicableIf";
+ newName = "TermNode_DefinedTermBase_InapplicableIf";
includeDtype = false;
step = TableNameChanger.NewInstance(stepName, oldName, newName, INCLUDE_AUDIT, includeDtype);
stepList.add(step);
- //#6794 change FeatureNode_id to TermTreeNode_id in TermTreeNode_DefinedTermBase_InapplicableIf
- stepName = "change FeatureNode_id to TermTreeNode_id in TermTreeNode_DefinedTermBase_InapplicableIf";
- tableName = "TermTreeNode_DefinedTermBase_InapplicableIf";
+ //#6794 change FeatureNode_id to TermNode_id in TermNode_DefinedTermBase_InapplicableIf
+ stepName = "change FeatureNode_id to TermNode_id in TermNode_DefinedTermBase_InapplicableIf";
+ tableName = "TermNode_DefinedTermBase_InapplicableIf";
oldColumnName = "FeatureNode_id";
- newColumnName = "TermTreeNode_id";
+ newColumnName = "TermNode_id";
step = ColumnNameChanger.NewIntegerInstance(stepName, tableName, oldColumnName, newColumnName, INCLUDE_AUDIT);
stepList.add(step);
- //#6794 rename FeatureNode_DefinedTermBase_OnlyApplicable to TermTreeNode_DefinedTermBase_OnlyApplicable
- stepName = "rename FeatureNode_DefinedTermBase_InapplicableIf to TermTreeNode_DefinedTermBase_InapplicableIf";
+ //#6794 rename FeatureNode_DefinedTermBase_OnlyApplicable to TermNode_DefinedTermBase_OnlyApplicable
+ stepName = "rename FeatureNode_DefinedTermBase_InapplicableIf to TermNode_DefinedTermBase_InapplicableIf";
oldName = "FeatureNode_DefinedTermBase_OnlyApplicable";
- newName = "TermTreeNode_DefinedTermBase_OnlyApplicable";
+ newName = "TermNode_DefinedTermBase_OnlyApplicable";
includeDtype = false;
step = TableNameChanger.NewInstance(stepName, oldName, newName, INCLUDE_AUDIT, includeDtype);
stepList.add(step);
- //#6794 change FeatureNode_id to TermTreeNode_id in TermTreeNode_DefinedTermBase_OnlyApplicable
- stepName = "change FeatureNode_id to TermTreeNode_id in TermTreeNode_DefinedTermBase_OnlyApplicable";
- tableName = "TermTreeNode_DefinedTermBase_OnlyApplicable";
+ //#6794 change FeatureNode_id to TermNode_id in TermNode_DefinedTermBase_OnlyApplicable
+ stepName = "change FeatureNode_id to TermNode_id in TermNode_DefinedTermBase_OnlyApplicable";
+ tableName = "TermNode_DefinedTermBase_OnlyApplicable";
oldColumnName = "FeatureNode_id";
- newColumnName = "TermTreeNode_id";
+ newColumnName = "TermNode_id";
step = ColumnNameChanger.NewIntegerInstance(stepName, tableName, oldColumnName, newColumnName, INCLUDE_AUDIT);
stepList.add(step);
import java.util.UUID;\r
\r
import eu.etaxonomy.cdm.model.term.TermTree;\r
-import eu.etaxonomy.cdm.model.term.TermTreeNode;\r
+import eu.etaxonomy.cdm.model.term.TermNode;\r
import eu.etaxonomy.cdm.model.term.TermType;\r
import eu.etaxonomy.cdm.persistence.dao.common.IIdentifiableDao;\r
import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;\r
* @param nodes\r
* @param nodePaths\r
*/\r
- public void deepLoadNodes(List<TermTreeNode> nodes, List<String> nodePaths);\r
+ public void deepLoadNodes(List<TermNode> nodes, List<String> nodePaths);\r
\r
public <S extends TermTree> List<UuidAndTitleCache<S>> getUuidAndTitleCacheByTermType(Class<S> clazz, TermType termType, Integer limit,\r
String pattern);\r
import java.util.List;
-import eu.etaxonomy.cdm.model.term.TermTreeNode;
+import eu.etaxonomy.cdm.model.term.TermNode;
import eu.etaxonomy.cdm.persistence.dao.common.IVersionableDao;
/**
* @author a.babadshanjan
* @since 09.09.2008
*/
-public interface ITermTreeNodeDao extends IVersionableDao<TermTreeNode> {
+public interface ITermNodeDao extends IVersionableDao<TermNode> {
- public List<TermTreeNode> list();
+ public List<TermNode> list();
}
List<?> trees = queryTree.list();
- String ftSelect = "SELECT feature.id FROM TermTreeNode node join node.feature as feature " +
+ String ftSelect = "SELECT feature.id FROM TermNode node join node.feature as feature " +
" WHERE node.featureTree.id in (:trees) ";
Query ftQuery = getSession().createQuery(ftSelect);
ftQuery.setParameterList("trees", trees);
import org.hibernate.Criteria;
import org.springframework.stereotype.Repository;
-import eu.etaxonomy.cdm.model.term.TermTreeNode;
-import eu.etaxonomy.cdm.persistence.dao.description.ITermTreeNodeDao;
+import eu.etaxonomy.cdm.model.term.TermNode;
+import eu.etaxonomy.cdm.persistence.dao.description.ITermNodeDao;
import eu.etaxonomy.cdm.persistence.dao.hibernate.common.VersionableDaoBase;
/**
* @since 09.09.2008
*/
@Repository
-public class TermTreeNodeDaoImpl
- extends VersionableDaoBase<TermTreeNode>
- implements ITermTreeNodeDao {
+public class TermNodeDaoImpl
+ extends VersionableDaoBase<TermNode>
+ implements ITermNodeDao {
- public TermTreeNodeDaoImpl() {
- super(TermTreeNode.class);
+ public TermNodeDaoImpl() {
+ super(TermNode.class);
}
@Override
- public List<TermTreeNode> list() {
+ public List<TermNode> list() {
Criteria crit = getSession().createCriteria(type);
@SuppressWarnings("unchecked")
- List<TermTreeNode> result = crit.list();
+ List<TermNode> result = crit.list();
return result;
}
import eu.etaxonomy.cdm.model.description.Feature;
import eu.etaxonomy.cdm.model.term.TermTree;
-import eu.etaxonomy.cdm.model.term.TermTreeNode;
+import eu.etaxonomy.cdm.model.term.TermNode;
import eu.etaxonomy.cdm.model.term.TermType;
import eu.etaxonomy.cdm.model.term.TermVocabulary;
import eu.etaxonomy.cdm.model.term.VocabularyEnum;
}
@Override
- public void deepLoadNodes(List<TermTreeNode> nodes, List<String> nodePaths) {
+ public void deepLoadNodes(List<TermNode> nodes, List<String> nodePaths) {
defaultBeanInitializer.initializeAll(nodes, nodePaths);
- List<TermTreeNode> childrenOfChildren = new ArrayList<>();
- for(TermTreeNode node : nodes) {
+ List<TermNode> childrenOfChildren = new ArrayList<>();
+ for(TermNode node : nodes) {
if(node.getChildCount() > 0){
childrenOfChildren.addAll(node.getChildNodes());
}
if (ownerClass.contains("Description") && param.equals("descriptionElements")){
return "elements";
}
- if (ownerClass.startsWith("TermTreeNode") && param.equals("children")) {
+ if (ownerClass.startsWith("TermNode") && param.equals("children")) {
return "childNodes";
}
if (ownerClass.startsWith("Media") && param.equals("description")) {
import eu.etaxonomy.cdm.model.description.PolytomousKeyNode;
import eu.etaxonomy.cdm.model.taxon.TaxonNode;
import eu.etaxonomy.cdm.model.term.TermTree;
-import eu.etaxonomy.cdm.model.term.TermTreeNode;
+import eu.etaxonomy.cdm.model.term.TermNode;
/**
* @author cmathew
} else if(TermTree.class.isAssignableFrom(entityClazz)){
TermTree<?> tree = (TermTree)entity;
- for (TermTreeNode<?> node:tree.getRootChildren()){
+ for (TermNode<?> node:tree.getRootChildren()){
node.removeNullValueFromChildren();
if (node.getChildNodes() != null){
- for (TermTreeNode childNode: node.getChildNodes()){
+ for (TermNode childNode: node.getChildNodes()){
removeNullFromCollections(childNode);
}
}
}
- } else if (TermTreeNode.class.isAssignableFrom(entityClazz)){
- TermTreeNode node = (TermTreeNode)entity;
+ } else if (TermNode.class.isAssignableFrom(entityClazz)){
+ TermNode node = (TermNode)entity;
node.removeNullValueFromChildren();
}
EXTENSION,\r
EXTENSIONTYPE,\r
FEATURE,\r
- TERMTREENODE,\r
+ TERMNODE,\r
FEATURETREE,\r
GATHERINGEVENT,\r
GRANTEDAUTHORITYIMPL,\r
<mapping class="eu.etaxonomy.cdm.model.term.TermRelationshipType"/>
<mapping class="eu.etaxonomy.cdm.model.term.TermTree"/>
<mapping class="eu.etaxonomy.cdm.model.term.TermGraph"/>
- <mapping class="eu.etaxonomy.cdm.model.term.TermTreeNode"/>
+ <mapping class="eu.etaxonomy.cdm.model.term.TermNode"/>
<mapping class="eu.etaxonomy.cdm.model.term.TermRelation"/>
<mapping class="eu.etaxonomy.cdm.model.term.TermVocabulary"/>
import eu.etaxonomy.cdm.model.term.OrderedTermVocabulary;
import eu.etaxonomy.cdm.model.term.Representation;
import eu.etaxonomy.cdm.model.term.TermTree;
-import eu.etaxonomy.cdm.model.term.TermTreeNode;
+import eu.etaxonomy.cdm.model.term.TermNode;
import eu.etaxonomy.cdm.model.term.TermVocabulary;
import eu.etaxonomy.cdm.model.view.AuditEvent;
import eu.etaxonomy.cdm.persistence.dao.agent.IAgentDao;
DescriptionElementBase.class,
Distribution.class,
Feature.class,
- TermTreeNode.class,
+ TermNode.class,
TermTree.class,
MediaKey.class,
IndividualsAssociation.class,
<TAXONRELATIONSHIP_MARKER_AUD/>
<TERMRELATION/>
<TERMRELATION_AUD/>
- <TERMTREENODE_DEFINEDTERMBASE_INAPPLICABLEIF/>
- <TERMTREENODE_DEFINEDTERMBASE_INAPPLICABLEIF_AUD/>
- <TERMTREENODE_DEFINEDTERMBASE_ONLYAPPLICABLE/>
- <TERMTREENODE_DEFINEDTERMBASE_ONLYAPPLICABLE_AUD/>
+ <TERMNODE_DEFINEDTERMBASE_INAPPLICABLEIF/>
+ <TERMNODE_DEFINEDTERMBASE_INAPPLICABLEIF_AUD/>
+ <TERMNODE_DEFINEDTERMBASE_ONLYAPPLICABLE/>
+ <TERMNODE_DEFINEDTERMBASE_ONLYAPPLICABLE_AUD/>
<TERMCOLLECTION_ANNOTATION/>
<TERMCOLLECTION_ANNOTATION_AUD/>
<TERMCOLLECTION_CREDIT/>
<TAXONRELATIONSHIP_MARKER_AUD/>
<TERMRELATION/>
<TERMRELATION_AUD/>
-<TERMTREENODE_DEFINEDTERMBASE_INAPPLICABLEIF/>
-<TERMTREENODE_DEFINEDTERMBASE_INAPPLICABLEIF_AUD/>
-<TERMTREENODE_DEFINEDTERMBASE_ONLYAPPLICABLE/>
-<TERMTREENODE_DEFINEDTERMBASE_ONLYAPPLICABLE_AUD/>
+<TERMNODE_DEFINEDTERMBASE_INAPPLICABLEIF/>
+<TERMNODE_DEFINEDTERMBASE_INAPPLICABLEIF_AUD/>
+<TERMNODE_DEFINEDTERMBASE_ONLYAPPLICABLE/>
+<TERMNODE_DEFINEDTERMBASE_ONLYAPPLICABLE_AUD/>
<TERMCOLLECTION />
<TERMCOLLECTION_AUD />
<TERMCOLLECTION_REPRESENTATION />
import eu.etaxonomy.cdm.persistence.dao.description.IDescriptionElementDao;
import eu.etaxonomy.cdm.persistence.dao.description.IDescriptiveDataSetDao;
import eu.etaxonomy.cdm.persistence.dao.description.IFeatureDao;
-import eu.etaxonomy.cdm.persistence.dao.description.ITermTreeNodeDao;
+import eu.etaxonomy.cdm.persistence.dao.description.ITermNodeDao;
import eu.etaxonomy.cdm.persistence.dao.description.IFeatureTreeDao;
import eu.etaxonomy.cdm.persistence.dao.description.IStatisticalMeasurementValueDao;
import eu.etaxonomy.cdm.persistence.dao.name.ITaxonNameDao;
protected IDescriptionElementDao descriptionElementDao;
protected IFeatureTreeDao featureTreeDao;
protected IDescriptiveDataSetDao descriptiveDataSetDao;
- protected ITermTreeNodeDao featureNodeDao;
+ protected ITermNodeDao featureNodeDao;
protected IFeatureDao featureDao;
protected ITermVocabularyDao vocabularyDao;
protected IDefinedTermDao definedTermDao;
}
@Autowired
- protected void setFeatureNodeDao(ITermTreeNodeDao featureNodeDao) {
+ protected void setFeatureNodeDao(ITermNodeDao featureNodeDao) {
this.featureNodeDao = featureNodeDao;
}
import eu.etaxonomy.cdm.model.description.Feature;
import eu.etaxonomy.cdm.model.term.DefinedTermBase;
import eu.etaxonomy.cdm.model.term.TermTree;
-import eu.etaxonomy.cdm.model.term.TermTreeNode;
+import eu.etaxonomy.cdm.model.term.TermNode;
import eu.etaxonomy.cdm.model.term.TermVocabulary;
-import eu.etaxonomy.cdm.persistence.dao.description.ITermTreeNodeDao;
+import eu.etaxonomy.cdm.persistence.dao.description.ITermNodeDao;
/**
* @author n.hoffmann
*/
@Service
@Transactional(readOnly = false)
-public class FeatureNodeServiceImpl extends VersionableServiceBase<TermTreeNode, ITermTreeNodeDao> implements IFeatureNodeService {
+public class FeatureNodeServiceImpl extends VersionableServiceBase<TermNode, ITermNodeDao> implements IFeatureNodeService {
private static final Logger logger = Logger.getLogger(FeatureNodeServiceImpl.class);
@Override
@Autowired
- protected void setDao(ITermTreeNodeDao dao) {
+ protected void setDao(ITermNodeDao dao) {
this.dao = dao;
}
@Transactional(readOnly = false)
public DeleteResult deleteFeatureNode(UUID nodeUuid, FeatureNodeDeletionConfigurator config) {
DeleteResult result = new DeleteResult();
- TermTreeNode<Feature> node = HibernateProxyHelper.deproxy(dao.load(nodeUuid), TermTreeNode.class);
+ TermNode<Feature> node = HibernateProxyHelper.deproxy(dao.load(nodeUuid), TermNode.class);
result = isDeletable(nodeUuid, config);
if (result.isOk()){
- TermTreeNode<Feature> parent = node.getParent();
- parent = HibernateProxyHelper.deproxy(parent, TermTreeNode.class);
- List<TermTreeNode> children = new ArrayList(node.getChildNodes());
+ TermNode<Feature> parent = node.getParent();
+ parent = HibernateProxyHelper.deproxy(parent, TermNode.class);
+ List<TermNode> children = new ArrayList(node.getChildNodes());
if (config.getChildHandling().equals(ChildHandling.DELETE)){
- for (TermTreeNode child: children){
+ for (TermNode child: children){
deleteFeatureNode(child.getUuid(), config);
// node.removeChild(child);
}
if (parent != null){
parent.removeChild(node);
- for (TermTreeNode child: children){
+ for (TermNode child: children){
node.removeChild(child);
parent.addChild(child);
}
@Override
public UpdateResult addChildFeatureNode(UUID nodeUUID, UUID termChildUuid, int position){
- TermTreeNode node = load(nodeUUID);
+ TermNode node = load(nodeUUID);
DefinedTermBase child = HibernateProxyHelper.deproxy(termService.load(termChildUuid), DefinedTermBase.class);
- TermTreeNode childNode;
+ TermNode childNode;
UpdateResult result = new UpdateResult();
if(position<0) {
childNode = node.addChild(child);
@Override
public DeleteResult isDeletable(UUID nodeUuid, FeatureNodeDeletionConfigurator config){
- TermTreeNode<Feature> node = load(nodeUuid);
+ TermNode<Feature> node = load(nodeUuid);
DeleteResult result = new DeleteResult();
Set<CdmBase> references = commonService.getReferencingObjectsForDeletion(node);
for (CdmBase ref:references){
- if (ref instanceof TermTreeNode){
+ if (ref instanceof TermNode){
break;
}
if (ref instanceof TermTree){
@Override
public UpdateResult moveFeatureNode(UUID movedNodeUuid, UUID targetNodeUuid, int position) {
UpdateResult result = new UpdateResult();
- TermTreeNode<Feature> movedNode = HibernateProxyHelper.deproxy(load(movedNodeUuid), TermTreeNode.class);
- TermTreeNode<Feature> targetNode = HibernateProxyHelper.deproxy(load(targetNodeUuid), TermTreeNode.class);
- TermTreeNode<Feature> parent = HibernateProxyHelper.deproxy(movedNode.getParent(), TermTreeNode.class);
+ TermNode<Feature> movedNode = HibernateProxyHelper.deproxy(load(movedNodeUuid), TermNode.class);
+ TermNode<Feature> targetNode = HibernateProxyHelper.deproxy(load(targetNodeUuid), TermNode.class);
+ TermNode<Feature> parent = HibernateProxyHelper.deproxy(movedNode.getParent(), TermNode.class);
if(position<0){
targetNode.addChild(movedNode);
}
import eu.etaxonomy.cdm.common.monitor.IProgressMonitor;\r
import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;\r
import eu.etaxonomy.cdm.model.term.TermTree;\r
-import eu.etaxonomy.cdm.model.term.TermTreeNode;\r
+import eu.etaxonomy.cdm.model.term.TermNode;\r
import eu.etaxonomy.cdm.model.term.TermType;\r
import eu.etaxonomy.cdm.persistence.dao.description.IFeatureTreeDao;\r
-import eu.etaxonomy.cdm.persistence.dao.description.ITermTreeNodeDao;\r
+import eu.etaxonomy.cdm.persistence.dao.description.ITermNodeDao;\r
import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;\r
import eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy;\r
\r
@Transactional(readOnly = false)\r
public class FeatureTreeServiceImpl extends IdentifiableServiceBase<TermTree, IFeatureTreeDao> implements IFeatureTreeService {\r
\r
- private ITermTreeNodeDao featureNodeDao;\r
+ private ITermNodeDao featureNodeDao;\r
\r
@Autowired\r
private IFeatureNodeService featureNodeService;\r
}\r
\r
@Autowired\r
- protected void setFeatureNodeDao(ITermTreeNodeDao featureNodeDao) {\r
+ protected void setFeatureNodeDao(ITermNodeDao featureNodeDao) {\r
this.featureNodeDao = featureNodeDao;\r
}\r
\r
}\r
\r
@Override\r
- public List<TermTreeNode> getFeatureNodesAll() {\r
+ public List<TermNode> getFeatureNodesAll() {\r
return featureNodeDao.list();\r
}\r
\r
@Override\r
- public Map<UUID, TermTreeNode> saveFeatureNodesAll(Collection<TermTreeNode> featureNodeCollection) {\r
+ public Map<UUID, TermNode> saveFeatureNodesAll(Collection<TermNode> featureNodeCollection) {\r
return featureNodeDao.saveAll(featureNodeCollection);\r
}\r
\r
@Override\r
- public Map<UUID, TermTreeNode> saveOrUpdateFeatureNodesAll(Collection<TermTreeNode> featureNodeCollection) {\r
+ public Map<UUID, TermNode> saveOrUpdateFeatureNodesAll(Collection<TermNode> featureNodeCollection) {\r
return featureNodeDao.saveOrUpdateAll(featureNodeCollection);\r
}\r
\r
DeleteResult result = new DeleteResult();\r
TermTree tree = dao.load(featureTreeUuid);\r
\r
- TermTreeNode rootNode = HibernateProxyHelper.deproxy(tree.getRoot());\r
+ TermNode rootNode = HibernateProxyHelper.deproxy(tree.getRoot());\r
FeatureNodeDeletionConfigurator config = new FeatureNodeDeletionConfigurator();\r
config.setChildHandling(ChildHandling.DELETE);\r
result =featureNodeService.deleteFeatureNode(rootNode.getUuid(), config);\r
\r
import eu.etaxonomy.cdm.api.service.config.FeatureNodeDeletionConfigurator;\r
import eu.etaxonomy.cdm.model.term.DefinedTermBase;\r
-import eu.etaxonomy.cdm.model.term.TermTreeNode;\r
+import eu.etaxonomy.cdm.model.term.TermNode;\r
\r
/**\r
* @author n.hoffmann\r
* @since Aug 5, 2010\r
*/\r
-public interface IFeatureNodeService extends IVersionableService<TermTreeNode>{\r
+public interface IFeatureNodeService extends IVersionableService<TermNode>{\r
\r
DeleteResult isDeletable(UUID nodeUuid, FeatureNodeDeletionConfigurator config);\r
\r
public UpdateResult addChildFeatureNode(UUID parentNodeUUID, UUID termChildUuid, int position);\r
\r
/**\r
- * Moves a given {@link TermTreeNode} to the target node at the given position;\r
+ * Moves a given {@link TermNode} to the target node at the given position;\r
* @param movedNodeUuid the node to move\r
* @param targetNodeUuid the target node\r
* @param position the position in the list of children of the target node\r
public UpdateResult moveFeatureNode(UUID movedNodeUuid, UUID targetNodeUuid, int position);\r
\r
/**\r
- * Moves a given {@link TermTreeNode} to the target node;\r
+ * Moves a given {@link TermNode} to the target node;\r
* @param movedNodeUuid the node to move\r
* @param targetNodeUuid the target node\r
* @return the result of the operation\r
import java.util.UUID;\r
\r
import eu.etaxonomy.cdm.model.term.TermTree;\r
-import eu.etaxonomy.cdm.model.term.TermTreeNode;\r
+import eu.etaxonomy.cdm.model.term.TermNode;\r
import eu.etaxonomy.cdm.model.term.TermType;\r
import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;\r
\r
public interface IFeatureTreeService extends IIdentifiableEntityService<TermTree> {\r
\r
- public List<TermTreeNode> getFeatureNodesAll();\r
+ public List<TermNode> getFeatureNodesAll();\r
\r
/**\r
* Loads a feature tree including all of its nodes (all the way down to the tips of the tree).\r
*/\r
public TermTree loadWithNodes(UUID uuid, List<String> propertyPaths, List<String> nodePaths);\r
\r
- public Map<UUID, TermTreeNode> saveFeatureNodesAll(Collection<TermTreeNode> featureNodeCollection);\r
+ public Map<UUID, TermNode> saveFeatureNodesAll(Collection<TermNode> featureNodeCollection);\r
\r
- public Map<UUID, TermTreeNode> saveOrUpdateFeatureNodesAll(Collection<TermTreeNode> featureNodeCollection);\r
+ public Map<UUID, TermNode> saveOrUpdateFeatureNodesAll(Collection<TermNode> featureNodeCollection);\r
\r
public TermTree createTransientDefaultFeatureTree();\r
\r
import eu.etaxonomy.cdm.model.description.TextData;
import eu.etaxonomy.cdm.model.description.TextFormat;
import eu.etaxonomy.cdm.model.term.TermTree;
-import eu.etaxonomy.cdm.model.term.TermTreeNode;
+import eu.etaxonomy.cdm.model.term.TermNode;
/**
* @param floor integer to keep track of the level in the tree
* @return a list of TextData elements containing the part of description corresponding to the feature node considered
*/
- private List<TextData> buildBranchesDescr(List<TermTreeNode> children, TermTreeNode<Feature> parent, TaxonDescription description, List<Language> languages, int floor) {
+ private List<TextData> buildBranchesDescr(List<TermNode> children, TermNode<Feature> parent, TaxonDescription description, List<Language> languages, int floor) {
List<TextData> listTextData = new ArrayList<TextData>();
floor++; // counter to know the current level in the tree
featureName = new TextData(); // else an empty TextData is created (because we keep track of the features, it is useful to inform when the upper node has no feature attached)
}
- for (Iterator<TermTreeNode> ifn = children.iterator() ; ifn.hasNext() ;){
+ for (Iterator<TermNode> ifn = children.iterator() ; ifn.hasNext() ;){
previousTextData = featureName; // this allows to keep track of the name of the feature one level up in the tree
- TermTreeNode fn = ifn.next();
+ TermNode fn = ifn.next();
listTextData.addAll(buildBranchesDescr(fn.getChildNodes(),fn,description, languages, floor));
}
}
import eu.etaxonomy.cdm.model.taxon.TaxonNode;\r
import eu.etaxonomy.cdm.model.term.DefinedTermBase;\r
import eu.etaxonomy.cdm.model.term.TermTree;\r
-import eu.etaxonomy.cdm.model.term.TermTreeNode;\r
+import eu.etaxonomy.cdm.model.term.TermNode;\r
import eu.etaxonomy.cdm.model.term.TermVocabulary;\r
\r
/**\r
services.add(new EntityValidationUnit(Collection.class, appConfig.getCollectionService()));\r
// services.add(new EntityValidationUnit(OriginalSourceBase.class, appConfig.getCommonService()));\r
services.add(new EntityValidationUnit(DescriptionBase.class, appConfig.getDescriptionService()));
- services.add(new EntityValidationUnit(TermTreeNode.class, appConfig.getFeatureNodeService()));
+ services.add(new EntityValidationUnit(TermNode.class, appConfig.getFeatureNodeService()));
services.add(new EntityValidationUnit(TermTree.class, appConfig.getFeatureTreeService()));
services.add(new EntityValidationUnit(Group.class, appConfig.getGroupService()));\r
import eu.etaxonomy.cdm.model.common.ITreeNode;
import eu.etaxonomy.cdm.model.description.Feature;
import eu.etaxonomy.cdm.model.term.TermTree;
-import eu.etaxonomy.cdm.model.term.TermTreeNode;
+import eu.etaxonomy.cdm.model.term.TermNode;
import eu.etaxonomy.cdm.test.integration.CdmTransactionalIntegrationTest;
/**
private static final UUID node5Uuid = UUID.fromString("c4d5170a-7967-4dac-ab76-ae2019eefde5");
private static final UUID node6Uuid = UUID.fromString("b419ba5e-9c8b-449c-ad86-7abfca9a7340");
- private TermTreeNode<Feature> node3;
- private TermTreeNode<Feature> node2;
+ private TermNode<Feature> node3;
+ private TermNode<Feature> node2;
@Before
featureTreeService.save(featureTree);
Feature feature = (Feature)termService.find(914);
- TermTreeNode<Feature> newNode = featureTree.getRoot().addChild(feature);
+ TermNode<Feature> newNode = featureTree.getRoot().addChild(feature);
featureTreeService.save(featureTree);
featureNodeService.saveOrUpdate(newNode);
node2 = featureNodeService.load(node2Uuid);
String oldTreeIndex = node2.treeIndex();
- TermTreeNode<Feature> newNode = node2.addChild(feature);
+ TermNode<Feature> newNode = node2.addChild(feature);
featureNodeService.saveOrUpdate(node2);
commitAndStartNewTransaction(new String[]{"FeatureNode"});
node3.addChild(node2);
featureNodeService.saveOrUpdate(node2);
commitAndStartNewTransaction(new String[]{"FeatureNode"});
- TermTreeNode<?> node6 = featureNodeService.load(node6Uuid);
+ TermNode<?> node6 = featureNodeService.load(node6Uuid);
Assert.assertEquals("Node6 treeindex is not correct", node3.treeIndex() + "2#4#6#", node6.treeIndex());
//root of new feature tree
//into new classification
node3 = featureNodeService.load(node3Uuid);
- TermTreeNode<Feature> node5 = featureNodeService.load(node5Uuid);
+ TermNode<Feature> node5 = featureNodeService.load(node5Uuid);
node5.addChild(node3);
featureNodeService.saveOrUpdate(node5);
commitAndStartNewTransaction(new String[]{"TaxonNode"});
@DataSet(loadStrategy=RefreshLoadStrategy.class, value="FeatureNodeServiceImplTest-indexing.xml")
public final void testIndexDeleteNode() {
node2 = featureNodeService.load(node2Uuid);
- TermTreeNode<Feature> root = node2.getParent();
+ TermNode<Feature> root = node2.getParent();
FeatureNodeDeletionConfigurator config = new FeatureNodeDeletionConfigurator();
config.setDeleteElement(false);
config.setChildHandling(ChildHandling.MOVE_TO_PARENT);
assertNull(node2);
node3 = featureNodeService.load(node3Uuid);
assertNotNull(node3);
- TermTreeNode node4 = featureNodeService.load(node4Uuid);
+ TermNode node4 = featureNodeService.load(node4Uuid);
assertNotNull(node4);
config.setDeleteElement(false);
config.setChildHandling(ChildHandling.DELETE);
tree1 = featureTreeService.load(featureTreeUuid);
node4 = featureNodeService.load(node4Uuid);
assertNull(node4);
- TermTreeNode node6 = featureNodeService.load(node6Uuid);
+ TermNode node6 = featureNodeService.load(node6Uuid);
assertNull(node6);
HibernateProxyHelper.deproxy(tree1, TermTree.class);
- TermTreeNode rootNode = HibernateProxyHelper.deproxy(tree1.getRoot(), TermTreeNode.class);
+ TermNode rootNode = HibernateProxyHelper.deproxy(tree1.getRoot(), TermNode.class);
assertNotNull(tree1);
featureTreeService.delete(tree1.getUuid());
commitAndStartNewTransaction(/*new String[]{"TaxonNode"}*/);
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;
import eu.etaxonomy.cdm.model.taxon.Taxon;
import eu.etaxonomy.cdm.model.term.TermTree;
-import eu.etaxonomy.cdm.model.term.TermTreeNode;
+import eu.etaxonomy.cdm.model.term.TermNode;
import eu.etaxonomy.cdm.test.integration.CdmIntegrationTest;
@Ignore //FIXME Remove @Ignore once maximes code is completely committed
description = TaxonDescription.NewInstance(taxon);
featureTree= TermTree.NewInstance();
- TermTreeNode<Feature> root = featureTree.getRoot();
+ TermNode<Feature> root = featureTree.getRoot();
String[][][] tableStrings = { { {"a","b"} } , { { "a1" , "a2" } , { "b1" } } };
buildBranches(root,tableStrings,0,2,0);
for (Iterator<Feature> f = featureSet.iterator() ; f.hasNext() ;){
System.out.println(stringBuilder.toString());
}
- public void buildBranches(TermTreeNode parent, String[][][] children, int level, int depth, int nodeNumber) {
+ public void buildBranches(TermNode parent, String[][][] children, int level, int depth, int nodeNumber) {
int i = nodeNumber;
int j;
for (j=0; j<children[level][i].length ; j++) {
Feature feature = Feature.NewInstance(null, children[level][i][j], null);
featureSet.add(feature);
- TermTreeNode<Feature> child = parent.addChild(feature);
+ TermNode<Feature> child = parent.addChild(feature);
if (level<depth-1) {
buildBranches(child, children,level+1,depth, j);
}
\r
<TERMCOLLECTION DTYPE="TermVocabulary" TERMTYPE="FE" ID="16" CREATED="2009-01-28 17:07:04.0" UUID="b187d555-f06f-4d65-9e53-da7c93f8eaa8" URI="" TERMSOURCEURI="eu.etaxonomy.cdm.model.description.Feature" PROTECTEDTITLECACHE="true" TITLECACHE=""/>\r
\r
- <TERMRELATION DTYPE="TermTreeNode" TERMTYPE="FE" ID="1" TERM_ID="[null]" PARENT_ID="[null]" TREEINDEX="#t5001#1#" SORTINDEX="[null]" GRAPH_ID="5001" UUID="324a1a77-689c-44be-8e65-347d835f4111" />\r
- <TERMRELATION DTYPE="TermTreeNode" TERMTYPE="FE" ID="2" TERM_ID="912" PARENT_ID="1" TREEINDEX="#t5001#1#2#" SORTINDEX="0" GRAPH_ID="5001" UUID="484a1a77-689c-44be-8e65-347d835f47e8" />\r
- <TERMRELATION DTYPE="TermTreeNode" TERMTYPE="FE" ID="3" TERM_ID="913" PARENT_ID="1" TREEINDEX="#t5001#1#3#" SORTINDEX="1" GRAPH_ID="5001" UUID="2d41f0c2-b785-4f73-a436-cc2d5e93cc5b" />\r
- <TERMRELATION DTYPE="TermTreeNode" TERMTYPE="FE" ID="4" TERM_ID="913" PARENT_ID="2" TREEINDEX="#t5001#1#2#4#" SORTINDEX="0" GRAPH_ID="5001" UUID="fdaec4bd-c78e-44df-ae87-28f18110968c" />\r
- <TERMRELATION DTYPE="TermTreeNode" TERMTYPE="FE" ID="5" TERM_ID="913" PARENT_ID="2" TREEINDEX="#t5001#1#2#5#" SORTINDEX="1" GRAPH_ID="5001" UUID="c4d5170a-7967-4dac-ab76-ae2019eefde5" />\r
- <TERMRELATION DTYPE="TermTreeNode" TERMTYPE="FE" ID="6" TERM_ID="913" PARENT_ID="4" TREEINDEX="#t5001#1#2#4#6#" SORTINDEX="0" GRAPH_ID="5001" UUID="b419ba5e-9c8b-449c-ad86-7abfca9a7340" />\r
- <TERMRELATION DTYPE="TermTreeNode" TERMTYPE="FE" ID="7" TERM_ID="913" PARENT_ID="[null]" TREEINDEX="#t2#7#" SORTINDEX="0" GRAPH_ID="5002" UUID="bb2c2d69-2b36-4f21-9374-b375ada8448c" />
+ <TERMRELATION DTYPE="TermNode" TERMTYPE="FE" ID="1" TERM_ID="[null]" PARENT_ID="[null]" TREEINDEX="#t5001#1#" SORTINDEX="[null]" GRAPH_ID="5001" UUID="324a1a77-689c-44be-8e65-347d835f4111" />\r
+ <TERMRELATION DTYPE="TermNode" TERMTYPE="FE" ID="2" TERM_ID="912" PARENT_ID="1" TREEINDEX="#t5001#1#2#" SORTINDEX="0" GRAPH_ID="5001" UUID="484a1a77-689c-44be-8e65-347d835f47e8" />\r
+ <TERMRELATION DTYPE="TermNode" TERMTYPE="FE" ID="3" TERM_ID="913" PARENT_ID="1" TREEINDEX="#t5001#1#3#" SORTINDEX="1" GRAPH_ID="5001" UUID="2d41f0c2-b785-4f73-a436-cc2d5e93cc5b" />\r
+ <TERMRELATION DTYPE="TermNode" TERMTYPE="FE" ID="4" TERM_ID="913" PARENT_ID="2" TREEINDEX="#t5001#1#2#4#" SORTINDEX="0" GRAPH_ID="5001" UUID="fdaec4bd-c78e-44df-ae87-28f18110968c" />\r
+ <TERMRELATION DTYPE="TermNode" TERMTYPE="FE" ID="5" TERM_ID="913" PARENT_ID="2" TREEINDEX="#t5001#1#2#5#" SORTINDEX="1" GRAPH_ID="5001" UUID="c4d5170a-7967-4dac-ab76-ae2019eefde5" />\r
+ <TERMRELATION DTYPE="TermNode" TERMTYPE="FE" ID="6" TERM_ID="913" PARENT_ID="4" TREEINDEX="#t5001#1#2#4#6#" SORTINDEX="0" GRAPH_ID="5001" UUID="b419ba5e-9c8b-449c-ad86-7abfca9a7340" />\r
+ <TERMRELATION DTYPE="TermNode" TERMTYPE="FE" ID="7" TERM_ID="913" PARENT_ID="[null]" TREEINDEX="#t2#7#" SORTINDEX="0" GRAPH_ID="5002" UUID="bb2c2d69-2b36-4f21-9374-b375ada8448c" />
\r
</dataset>
\ No newline at end of file
<TAXONRELATIONSHIP_MARKER_AUD/>
<TERMRELATION/>
<TERMRELATION_AUD/>
- <TERMTREENODE_DEFINEDTERMBASE_INAPPLICABLEIF/>
- <TERMTREENODE_DEFINEDTERMBASE_INAPPLICABLEIF_AUD/>
- <TERMTREENODE_DEFINEDTERMBASE_ONLYAPPLICABLE/>
- <TERMTREENODE_DEFINEDTERMBASE_ONLYAPPLICABLE_AUD/>
+ <TERMNODE_DEFINEDTERMBASE_INAPPLICABLEIF/>
+ <TERMNODE_DEFINEDTERMBASE_INAPPLICABLEIF_AUD/>
+ <TERMNODE_DEFINEDTERMBASE_ONLYAPPLICABLE/>
+ <TERMNODE_DEFINEDTERMBASE_ONLYAPPLICABLE_AUD/>
<TERMCOLLECTION_ANNOTATION/>
<TERMCOLLECTION_ANNOTATION_AUD/>
<TERMCOLLECTION_CREDIT/>
<TAXONRELATIONSHIP_MARKER_AUD/>
<TERMRELATION/>
<TERMRELATION_AUD/>
-<TERMTREENODE_DEFINEDTERMBASE_INAPPLICABLEIF/>
-<TERMTREENODE_DEFINEDTERMBASE_INAPPLICABLEIF_AUD/>
-<TERMTREENODE_DEFINEDTERMBASE_ONLYAPPLICABLE/>
-<TERMTREENODE_DEFINEDTERMBASE_ONLYAPPLICABLE_AUD/>
+<TERMNODE_DEFINEDTERMBASE_INAPPLICABLEIF/>
+<TERMNODE_DEFINEDTERMBASE_INAPPLICABLEIF_AUD/>
+<TERMNODE_DEFINEDTERMBASE_ONLYAPPLICABLE/>
+<TERMNODE_DEFINEDTERMBASE_ONLYAPPLICABLE_AUD/>
<TERMCOLLECTION />
<TERMCOLLECTION_AUD />
<TERMCOLLECTION_REPRESENTATION />
PARENT_ID INTEGER
);
-- 0 +/- SELECT COUNT(*) FROM PUBLIC.TERMRELATION_AUD;
-CREATE CACHED TABLE PUBLIC.TERMTREENODE_DEFINEDTERMBASE_INAPPLICABLEIF(
- TERMTREENODE_ID INTEGER NOT NULL,
+CREATE CACHED TABLE PUBLIC.TERMNODE_DEFINEDTERMBASE_INAPPLICABLEIF(
+ TERMNODE_ID INTEGER NOT NULL,
INAPPLICABLEIF_ID INTEGER NOT NULL
);
--- 0 +/- SELECT COUNT(*) FROM PUBLIC.TERMTREENODE_DEFINEDTERMBASE_INAPPLICABLEIF;
-CREATE CACHED TABLE PUBLIC.TERMTREENODE_DEFINEDTERMBASE_INAPPLICABLEIF_AUD(
+-- 0 +/- SELECT COUNT(*) FROM PUBLIC.TERMNODE_DEFINEDTERMBASE_INAPPLICABLEIF;
+CREATE CACHED TABLE PUBLIC.TERMNODE_DEFINEDTERMBASE_INAPPLICABLEIF_AUD(
REV INTEGER NOT NULL,
- TERMTREENODE_ID INTEGER NOT NULL,
+ TERMNODE_ID INTEGER NOT NULL,
INAPPLICABLEIF_ID INTEGER NOT NULL,
REVTYPE TINYINT
);
--- 0 +/- SELECT COUNT(*) FROM PUBLIC.TERMTREENODE_DEFINEDTERMBASE_INAPPLICABLEIF_AUD;
-CREATE CACHED TABLE PUBLIC.TERMTREENODE_DEFINEDTERMBASE_ONLYAPPLICABLE(
- TERMTREENODE_ID INTEGER NOT NULL,
+-- 0 +/- SELECT COUNT(*) FROM PUBLIC.TERMNODE_DEFINEDTERMBASE_INAPPLICABLEIF_AUD;
+CREATE CACHED TABLE PUBLIC.TERMNODE_DEFINEDTERMBASE_ONLYAPPLICABLE(
+ TERMNODE_ID INTEGER NOT NULL,
ONLYAPPLICABLEIF_ID INTEGER NOT NULL
);
--- 0 +/- SELECT COUNT(*) FROM PUBLIC.TERMTREENODE_DEFINEDTERMBASE_ONLYAPPLICABLE;
-CREATE CACHED TABLE PUBLIC.TERMTREENODE_DEFINEDTERMBASE_ONLYAPPLICABLE_AUD(
+-- 0 +/- SELECT COUNT(*) FROM PUBLIC.TERMNODE_DEFINEDTERMBASE_ONLYAPPLICABLE;
+CREATE CACHED TABLE PUBLIC.TERMNODE_DEFINEDTERMBASE_ONLYAPPLICABLE_AUD(
REV INTEGER NOT NULL,
- TERMTREENODE_ID INTEGER NOT NULL,
+ TERMNODE_ID INTEGER NOT NULL,
ONLYAPPLICABLEIF_ID INTEGER NOT NULL,
REVTYPE TINYINT
);
--- 0 +/- SELECT COUNT(*) FROM PUBLIC.TERMTREENODE_DEFINEDTERMBASE_ONLYAPPLICABLE_AUD;
+-- 0 +/- SELECT COUNT(*) FROM PUBLIC.TERMNODE_DEFINEDTERMBASE_ONLYAPPLICABLE_AUD;
CREATE CACHED TABLE PUBLIC.TYPEDESIGNATIONBASE(
DTYPE VARCHAR(31) NOT NULL,
ID INTEGER NOT NULL,
ALTER TABLE PUBLIC.TAXONBASE_ORIGINALSOURCEBASE_AUD ADD CONSTRAINT PUBLIC.CONSTRAINT_XXXE3C PRIMARY KEY(REV, TAXONBASE_ID, SOURCES_ID);
ALTER TABLE PUBLIC.SPECIMENOROBSERVATIONBASE_AUD ADD CONSTRAINT PUBLIC.CONSTRAINT_XXXC81E PRIMARY KEY(ID, REV);
ALTER TABLE PUBLIC.TAXONNAME_MARKER ADD CONSTRAINT PUBLIC.CONSTRAINT_XXX98E PRIMARY KEY(TAXONNAME_ID, MARKERS_ID);
-ALTER TABLE PUBLIC.TERMTREENODE_DEFINEDTERMBASE_ONLYAPPLICABLE ADD CONSTRAINT PUBLIC.CONSTRAINT_XXXA85 PRIMARY KEY(TERMTREENODE_ID, ONLYAPPLICABLEIF_ID);
+ALTER TABLE PUBLIC.TERMNODE_DEFINEDTERMBASE_ONLYAPPLICABLE ADD CONSTRAINT PUBLIC.CONSTRAINT_XXXA85 PRIMARY KEY(TERMNODE_ID, ONLYAPPLICABLEIF_ID);
ALTER TABLE PUBLIC.DESCRIPTIVEDATASET_AUD ADD CONSTRAINT PUBLIC.CONSTRAINT_XXXB92 PRIMARY KEY(ID, REV);
ALTER TABLE PUBLIC.NOMENCLATURALSTATUS_MARKER ADD CONSTRAINT PUBLIC.CONSTRAINT_XXXB5D PRIMARY KEY(NOMENCLATURALSTATUS_ID, MARKERS_ID);
ALTER TABLE PUBLIC.DESCRIPTIONBASE_ANNOTATION_AUD ADD CONSTRAINT PUBLIC.CONSTRAINT_XXXA82 PRIMARY KEY(REV, DESCRIPTIONBASE_ID, ANNOTATIONS_ID);
ALTER TABLE PUBLIC.MEDIAKEY_TAXONSCOPE ADD CONSTRAINT PUBLIC.CONSTRAINT_XXX3AB PRIMARY KEY(MEDIAKEY_ID, TAXONOMICSCOPE_ID);
ALTER TABLE PUBLIC.DERIVATIONEVENT ADD CONSTRAINT PUBLIC.CONSTRAINT_XXX83E PRIMARY KEY(ID);
ALTER TABLE PUBLIC.TERMCOLLECTION_AUD ADD CONSTRAINT PUBLIC.CONSTRAINT_XXXDDD PRIMARY KEY(ID, REV);
-ALTER TABLE PUBLIC.TERMTREENODE_DEFINEDTERMBASE_ONLYAPPLICABLE_AUD ADD CONSTRAINT PUBLIC.CONSTRAINT_XXX3F PRIMARY KEY(REV, TERMTREENODE_ID, ONLYAPPLICABLEIF_ID);
+ALTER TABLE PUBLIC.TERMNODE_DEFINEDTERMBASE_ONLYAPPLICABLE_AUD ADD CONSTRAINT PUBLIC.CONSTRAINT_XXX3F PRIMARY KEY(REV, TERMNODE_ID, ONLYAPPLICABLEIF_ID);
ALTER TABLE PUBLIC.MEDIAKEY_COVEREDTAXON ADD CONSTRAINT PUBLIC.CONSTRAINT_XXXAA PRIMARY KEY(MEDIAKEY_ID, COVEREDTAXA_ID);
ALTER TABLE PUBLIC.DEFINEDTERMBASE_COUNTRY_AUD ADD CONSTRAINT PUBLIC.CONSTRAINT_XXX96 PRIMARY KEY(REV, NAMEDAREA_ID, COUNTRIES_ID);
ALTER TABLE PUBLIC.MULTIACCESSKEY_COVEREDTAXON ADD CONSTRAINT PUBLIC.CONSTRAINT_XXXCAA PRIMARY KEY(MULTIACCESSKEY_ID, COVEREDTAXA_ID);
ALTER TABLE PUBLIC.MULTIACCESSKEY_NAMEDAREA ADD CONSTRAINT PUBLIC.CONSTRAINT_XXXCC2 PRIMARY KEY(MULTIACCESSKEY_ID, GEOGRAPHICALSCOPE_ID);
ALTER TABLE PUBLIC.NOMENCLATURALSTATUS_ANNOTATION ADD CONSTRAINT PUBLIC.CONSTRAINT_XXX879 PRIMARY KEY(NOMENCLATURALSTATUS_ID, ANNOTATIONS_ID);
ALTER TABLE PUBLIC.GATHERINGEVENT_DEFINEDTERMBASE_AUD ADD CONSTRAINT PUBLIC.CONSTRAINT_XXXC7 PRIMARY KEY(REV, GATHERINGEVENT_ID, COLLECTINGAREAS_ID);
-ALTER TABLE PUBLIC.TERMTREENODE_DEFINEDTERMBASE_INAPPLICABLEIF ADD CONSTRAINT PUBLIC.CONSTRAINT_XXXAC PRIMARY KEY(TERMTREENODE_ID, INAPPLICABLEIF_ID);
+ALTER TABLE PUBLIC.TERMNODE_DEFINEDTERMBASE_INAPPLICABLEIF ADD CONSTRAINT PUBLIC.CONSTRAINT_XXXAC PRIMARY KEY(TERMNODE_ID, INAPPLICABLEIF_ID);
ALTER TABLE PUBLIC.AGENTBASE_EXTENSION_AUD ADD CONSTRAINT PUBLIC.CONSTRAINT_XXXB9 PRIMARY KEY(REV, AGENTBASE_ID, EXTENSIONS_ID);
ALTER TABLE PUBLIC.ANNOTATION ADD CONSTRAINT PUBLIC.CONSTRAINT_XXXC0 PRIMARY KEY(ID);
ALTER TABLE PUBLIC.COLLECTION ADD CONSTRAINT PUBLIC.CONSTRAINT_XXXB5 PRIMARY KEY(ID);
ALTER TABLE PUBLIC.HOMOTYPICALGROUP_MARKER ADD CONSTRAINT PUBLIC.CONSTRAINT_XXXBC PRIMARY KEY(HOMOTYPICALGROUP_ID, MARKERS_ID);
ALTER TABLE PUBLIC.MEDIAREPRESENTATIONPART_AUD ADD CONSTRAINT PUBLIC.CONSTRAINT_XXX48 PRIMARY KEY(ID, REV);
ALTER TABLE PUBLIC.COLLECTION_EXTENSION ADD CONSTRAINT PUBLIC.CONSTRAINT_XXXBB PRIMARY KEY(COLLECTION_ID, EXTENSIONS_ID);
-ALTER TABLE PUBLIC.TERMTREENODE_DEFINEDTERMBASE_INAPPLICABLEIF_AUD ADD CONSTRAINT PUBLIC.CONSTRAINT_XXXB3 PRIMARY KEY(REV, TERMTREENODE_ID, INAPPLICABLEIF_ID);
+ALTER TABLE PUBLIC.TERMNODE_DEFINEDTERMBASE_INAPPLICABLEIF_AUD ADD CONSTRAINT PUBLIC.CONSTRAINT_XXXB3 PRIMARY KEY(REV, TERMNODE_ID, INAPPLICABLEIF_ID);
ALTER TABLE PUBLIC.PERMISSIONGROUP_GRANTEDAUTHORITYIMPL ADD CONSTRAINT PUBLIC.CONSTRAINT_XXXB1 PRIMARY KEY(GROUP_ID, GRANTEDAUTHORITIES_ID);
ALTER TABLE PUBLIC.DEFINEDTERMBASE_STATISTICALMEASURE ADD CONSTRAINT PUBLIC.CONSTRAINT_XXXB6 PRIMARY KEY(FEATURE_ID, RECOMMENDEDSTATISTICALMEASURES_ID);
ALTER TABLE PUBLIC.POLYTOMOUSKEY_SCOPE ADD CONSTRAINT PUBLIC.CONSTRAINT_XXXB7 PRIMARY KEY(POLYTOMOUSKEY_ID, SCOPERESTRICTIONS_ID);
ALTER TABLE PUBLIC.MEDIA_SEQUENCE_AUD ADD CONSTRAINT PUBLIC.FK3C7BD9CD34869AAE FOREIGN KEY(REV) REFERENCES PUBLIC.AUDITEVENT(REVISIONNUMBER) NOCHECK;
ALTER TABLE PUBLIC.TAXONBASE_CREDIT ADD CONSTRAINT PUBLIC.FK4CB48B3D9C9D39 FOREIGN KEY(TAXONBASE_ID) REFERENCES PUBLIC.TAXONBASE(ID) NOCHECK;
ALTER TABLE PUBLIC.DESCRIPTIONBASE ADD CONSTRAINT PUBLIC.FKFF4D58CDBC5DA539 FOREIGN KEY(UPDATEDBY_ID) REFERENCES PUBLIC.USERACCOUNT(ID) NOCHECK;
-ALTER TABLE PUBLIC.TERMTREENODE_DEFINEDTERMBASE_ONLYAPPLICABLE ADD CONSTRAINT PUBLIC.FK6AE876AB52FCC4B FOREIGN KEY(TERMTREENODE_ID) REFERENCES PUBLIC.TERMRELATION(ID) NOCHECK;
+ALTER TABLE PUBLIC.TERMNODE_DEFINEDTERMBASE_ONLYAPPLICABLE ADD CONSTRAINT PUBLIC.FK6AE876AB52FCC4B FOREIGN KEY(TERMNODE_ID) REFERENCES PUBLIC.TERMRELATION(ID) NOCHECK;
ALTER TABLE PUBLIC.COLLECTION_ORIGINALSOURCEBASE_AUD ADD CONSTRAINT PUBLIC.FKF810044F34869AAE FOREIGN KEY(REV) REFERENCES PUBLIC.AUDITEVENT(REVISIONNUMBER) NOCHECK;
ALTER TABLE PUBLIC.REPRESENTATION_ANNOTATION_AUD ADD CONSTRAINT PUBLIC.FK36EEE73234869AAE FOREIGN KEY(REV) REFERENCES PUBLIC.AUDITEVENT(REVISIONNUMBER) NOCHECK;
ALTER TABLE PUBLIC.MEDIA_RIGHTSINFO_AUD ADD CONSTRAINT PUBLIC.FKAB2ADBA334869AAE FOREIGN KEY(REV) REFERENCES PUBLIC.AUDITEVENT(REVISIONNUMBER) NOCHECK;
ALTER TABLE PUBLIC.AGENTBASE_RIGHTSINFO_AUD ADD CONSTRAINT PUBLIC.FK4FDFF8D134869AAE FOREIGN KEY(REV) REFERENCES PUBLIC.AUDITEVENT(REVISIONNUMBER) NOCHECK;
ALTER TABLE PUBLIC.MEDIAKEY_SCOPE ADD CONSTRAINT PUBLIC.FKBFFEE8F0546985E4 FOREIGN KEY(SCOPERESTRICTIONS_ID) REFERENCES PUBLIC.DEFINEDTERMBASE(ID) NOCHECK;
ALTER TABLE PUBLIC.TERMCOLLECTION_REPRESENTATION ADD CONSTRAINT PUBLIC.FKA408B63A258E060 FOREIGN KEY(TERMCOLLECTION_ID) REFERENCES PUBLIC.TERMCOLLECTION(ID) NOCHECK;
-ALTER TABLE PUBLIC.TERMTREENODE_DEFINEDTERMBASE_INAPPLICABLEIF ADD CONSTRAINT PUBLIC.FK56833D0152FCC4B FOREIGN KEY(TERMTREENODE_ID) REFERENCES PUBLIC.TERMRELATION(ID) NOCHECK;
+ALTER TABLE PUBLIC.TERMNODE_DEFINEDTERMBASE_INAPPLICABLEIF ADD CONSTRAINT PUBLIC.FK56833D0152FCC4B FOREIGN KEY(TERMNODE_ID) REFERENCES PUBLIC.TERMRELATION(ID) NOCHECK;
ALTER TABLE PUBLIC.POLYTOMOUSKEY_ORIGINALSOURCEBASE_AUD ADD CONSTRAINT PUBLIC.FKE644349534869AAE FOREIGN KEY(REV) REFERENCES PUBLIC.AUDITEVENT(REVISIONNUMBER) NOCHECK;
ALTER TABLE PUBLIC.COLLECTION_MEDIA_AUD ADD CONSTRAINT PUBLIC.FK9AABDB5434869AAE FOREIGN KEY(REV) REFERENCES PUBLIC.AUDITEVENT(REVISIONNUMBER) NOCHECK;
ALTER TABLE PUBLIC.DESCRIPTIONBASE ADD CONSTRAINT PUBLIC.FKDE29CD8033B8A841 FOREIGN KEY(SPECIMEN_ID) REFERENCES PUBLIC.SPECIMENOROBSERVATIONBASE(ID) NOCHECK;
ALTER TABLE PUBLIC.TAXONBASE_ANNOTATION_AUD ADD CONSTRAINT PUBLIC.FK8C145C434869AAE FOREIGN KEY(REV) REFERENCES PUBLIC.AUDITEVENT(REVISIONNUMBER) NOCHECK;
ALTER TABLE PUBLIC.DESCRIPTIONELEMENTBASE ADD CONSTRAINT PUBLIC.FK38FE7671E8D36B00 FOREIGN KEY(LANGUAGE_ID) REFERENCES PUBLIC.DEFINEDTERMBASE(ID) NOCHECK;
ALTER TABLE PUBLIC.MEDIA ADD CONSTRAINT PUBLIC.FK46C7FC4AEB7F3BE FOREIGN KEY(CITATION_ID) REFERENCES PUBLIC.REFERENCE(ID) NOCHECK;
-ALTER TABLE PUBLIC.TERMTREENODE_DEFINEDTERMBASE_ONLYAPPLICABLE ADD CONSTRAINT PUBLIC.FK6AE876AB57FA94D4 FOREIGN KEY(ONLYAPPLICABLEIF_ID) REFERENCES PUBLIC.DEFINEDTERMBASE(ID) NOCHECK;
+ALTER TABLE PUBLIC.TERMNODE_DEFINEDTERMBASE_ONLYAPPLICABLE ADD CONSTRAINT PUBLIC.FK6AE876AB57FA94D4 FOREIGN KEY(ONLYAPPLICABLEIF_ID) REFERENCES PUBLIC.DEFINEDTERMBASE(ID) NOCHECK;
ALTER TABLE PUBLIC.DESCRIPTIONELEMENTBASE_MODIFIER ADD CONSTRAINT PUBLIC.FK97E0D1053B8BB609 FOREIGN KEY(DESCRIPTIONELEMENTBASE_ID) REFERENCES PUBLIC.DESCRIPTIONELEMENTBASE(ID) NOCHECK;
ALTER TABLE PUBLIC.TERMRELATION ADD CONSTRAINT PUBLIC.FK4CEED9F84220AFEB FOREIGN KEY(TERM_ID) REFERENCES PUBLIC.DEFINEDTERMBASE(ID) NOCHECK;
ALTER TABLE PUBLIC.DEFINEDTERMBASE_STATISTICALMEASURE ADD CONSTRAINT PUBLIC.FK6FF15DFCD0BDAE9B FOREIGN KEY(FEATURE_ID) REFERENCES PUBLIC.DEFINEDTERMBASE(ID) NOCHECK;
ALTER TABLE PUBLIC.REFERENCE_MEDIA_AUD ADD CONSTRAINT PUBLIC.FK8318CB8134869AAE FOREIGN KEY(REV) REFERENCES PUBLIC.AUDITEVENT(REVISIONNUMBER) NOCHECK;
ALTER TABLE PUBLIC.INDIVIDUALSASSOCIATION_LANGUAGESTRING ADD CONSTRAINT PUBLIC.FKB5C75EC028459272 FOREIGN KEY(DESCRIPTION_MAPKEY_ID) REFERENCES PUBLIC.DEFINEDTERMBASE(ID) NOCHECK;
ALTER TABLE PUBLIC.MEDIAREPRESENTATIONPART ADD CONSTRAINT PUBLIC.FK67A45544BC5DA539 FOREIGN KEY(UPDATEDBY_ID) REFERENCES PUBLIC.USERACCOUNT(ID) NOCHECK;
-ALTER TABLE PUBLIC.TERMTREENODE_DEFINEDTERMBASE_INAPPLICABLEIF ADD CONSTRAINT PUBLIC.FK56833D011128E63B FOREIGN KEY(INAPPLICABLEIF_ID) REFERENCES PUBLIC.DEFINEDTERMBASE(ID) NOCHECK;
+ALTER TABLE PUBLIC.TERMNODE_DEFINEDTERMBASE_INAPPLICABLEIF ADD CONSTRAINT PUBLIC.FK56833D011128E63B FOREIGN KEY(INAPPLICABLEIF_ID) REFERENCES PUBLIC.DEFINEDTERMBASE(ID) NOCHECK;
ALTER TABLE PUBLIC.COLLECTION_CREDIT_AUD ADD CONSTRAINT PUBLIC.FK25A8D88B34869AAE FOREIGN KEY(REV) REFERENCES PUBLIC.AUDITEVENT(REVISIONNUMBER) NOCHECK;
ALTER TABLE PUBLIC.DEFINEDTERMBASE_SUPPORTEDCATEGORICALENUMERATION ADD CONSTRAINT PUBLIC.FK2170B25CD0BDAE9B FOREIGN KEY(FEATURE_ID) REFERENCES PUBLIC.DEFINEDTERMBASE(ID) NOCHECK;
ALTER TABLE PUBLIC.DERIVATIONEVENT_MARKER_AUD ADD CONSTRAINT PUBLIC.FK8ED0FAE734869AAE FOREIGN KEY(REV) REFERENCES PUBLIC.AUDITEVENT(REVISIONNUMBER) NOCHECK;
ALTER TABLE PUBLIC.SPECIMENOROBSERVATIONBASE_ANNOTATION ADD CONSTRAINT PUBLIC.FK365E4F3C1E403E0B FOREIGN KEY(ANNOTATIONS_ID) REFERENCES PUBLIC.ANNOTATION(ID) NOCHECK;
ALTER TABLE PUBLIC.STATEDATA ADD CONSTRAINT PUBLIC.FKFB1697BBBC5DA539 FOREIGN KEY(UPDATEDBY_ID) REFERENCES PUBLIC.USERACCOUNT(ID) NOCHECK;
ALTER TABLE PUBLIC.DEFINEDTERMBASE_ANNOTATION ADD CONSTRAINT PUBLIC.FK589B6C8C0DB4934 FOREIGN KEY(DEFINEDTERMBASE_ID) REFERENCES PUBLIC.DEFINEDTERMBASE(ID) NOCHECK;
-ALTER TABLE PUBLIC.TERMTREENODE_DEFINEDTERMBASE_ONLYAPPLICABLE_AUD ADD CONSTRAINT PUBLIC.FK3F5356FC34869AAE FOREIGN KEY(REV) REFERENCES PUBLIC.AUDITEVENT(REVISIONNUMBER) NOCHECK;
+ALTER TABLE PUBLIC.TERMNODE_DEFINEDTERMBASE_ONLYAPPLICABLE_AUD ADD CONSTRAINT PUBLIC.FK3F5356FC34869AAE FOREIGN KEY(REV) REFERENCES PUBLIC.AUDITEVENT(REVISIONNUMBER) NOCHECK;
ALTER TABLE PUBLIC.MULTIACCESSKEY_SCOPE ADD CONSTRAINT PUBLIC.FKCC6CE4F7546985E4 FOREIGN KEY(SCOPERESTRICTIONS_ID) REFERENCES PUBLIC.DEFINEDTERMBASE(ID) NOCHECK;
ALTER TABLE PUBLIC.AGENTBASE_ADDRESS ADD CONSTRAINT PUBLIC.FK1EDFF7EB86EFC5D4 FOREIGN KEY(AGENTBASE_ID) REFERENCES PUBLIC.AGENTBASE(ID) NOCHECK;
ALTER TABLE PUBLIC.SPECIMENOROBSERVATIONBASE_MARKER ADD CONSTRAINT PUBLIC.FK8E6106C7777265A1 FOREIGN KEY(MARKERS_ID) REFERENCES PUBLIC.MARKER(ID) NOCHECK;
ALTER TABLE PUBLIC.NOMENCLATURALSTATUS_MARKER_AUD ADD CONSTRAINT PUBLIC.FK8619495F34869AAE FOREIGN KEY(REV) REFERENCES PUBLIC.AUDITEVENT(REVISIONNUMBER) NOCHECK;
ALTER TABLE PUBLIC.NAMERELATIONSHIP_MARKER ADD CONSTRAINT PUBLIC.FKE3E463967B4CB560 FOREIGN KEY(NAMERELATIONSHIP_ID) REFERENCES PUBLIC.NAMERELATIONSHIP(ID) NOCHECK;
ALTER TABLE PUBLIC.SPECIMENOROBSERVATIONBASE_RIGHTSINFO_AUD ADD CONSTRAINT PUBLIC.FK4168503534869AAE FOREIGN KEY(REV) REFERENCES PUBLIC.AUDITEVENT(REVISIONNUMBER) NOCHECK;
-ALTER TABLE PUBLIC.TERMTREENODE_DEFINEDTERMBASE_INAPPLICABLEIF_AUD ADD CONSTRAINT PUBLIC.FKB8D7025234869AAE FOREIGN KEY(REV) REFERENCES PUBLIC.AUDITEVENT(REVISIONNUMBER) NOCHECK;
+ALTER TABLE PUBLIC.TERMNODE_DEFINEDTERMBASE_INAPPLICABLEIF_AUD ADD CONSTRAINT PUBLIC.FKB8D7025234869AAE FOREIGN KEY(REV) REFERENCES PUBLIC.AUDITEVENT(REVISIONNUMBER) NOCHECK;
ALTER TABLE PUBLIC.DESCRIPTIONELEMENTBASE_ORIGINALSOURCEBASE ADD CONSTRAINT PUBLIC.FKF41ADEEB3B8BB609 FOREIGN KEY(DESCRIPTIONELEMENTBASE_ID) REFERENCES PUBLIC.DESCRIPTIONELEMENTBASE(ID) NOCHECK;
ALTER TABLE PUBLIC.ADDRESS ADD CONSTRAINT PUBLIC.FK1ED033D4BC5DA539 FOREIGN KEY(UPDATEDBY_ID) REFERENCES PUBLIC.USERACCOUNT(ID) NOCHECK;
ALTER TABLE PUBLIC.DETERMINATIONEVENT_ANNOTATION ADD CONSTRAINT PUBLIC.FKB74F03F71E403E0B FOREIGN KEY(ANNOTATIONS_ID) REFERENCES PUBLIC.ANNOTATION(ID) NOCHECK;
<TAXONRELATIONSHIP_MARKER_AUD/>
<TERMRELATION/>
<TERMRELATION_AUD/>
- <TERMTREENODE_DEFINEDTERMBASE_INAPPLICABLEIF/>
- <TERMTREENODE_DEFINEDTERMBASE_INAPPLICABLEIF_AUD/>
- <TERMTREENODE_DEFINEDTERMBASE_ONLYAPPLICABLE/>
- <TERMTREENODE_DEFINEDTERMBASE_ONLYAPPLICABLE_AUD/>
+ <TERMNODE_DEFINEDTERMBASE_INAPPLICABLEIF/>
+ <TERMNODE_DEFINEDTERMBASE_INAPPLICABLEIF_AUD/>
+ <TERMNODE_DEFINEDTERMBASE_ONLYAPPLICABLE/>
+ <TERMNODE_DEFINEDTERMBASE_ONLYAPPLICABLE_AUD/>
<TERMCOLLECTION_ANNOTATION/>
<TERMCOLLECTION_ANNOTATION_AUD/>
<TERMCOLLECTION_CREDIT/>
<TAXONRELATIONSHIP_MARKER_AUD/>
<TERMRELATION/>
<TERMRELATION_AUD/>
-<TERMTREENODE_DEFINEDTERMBASE_INAPPLICABLEIF/>
-<TERMTREENODE_DEFINEDTERMBASE_INAPPLICABLEIF_AUD/>
-<TERMTREENODE_DEFINEDTERMBASE_ONLYAPPLICABLE/>
-<TERMTREENODE_DEFINEDTERMBASE_ONLYAPPLICABLE_AUD/>
+<TERMNODE_DEFINEDTERMBASE_INAPPLICABLEIF/>
+<TERMNODE_DEFINEDTERMBASE_INAPPLICABLEIF_AUD/>
+<TERMNODE_DEFINEDTERMBASE_ONLYAPPLICABLE/>
+<TERMNODE_DEFINEDTERMBASE_ONLYAPPLICABLE_AUD/>
<TERMCOLLECTION />
<TERMCOLLECTION_AUD />
<TERMCOLLECTION_REPRESENTATION />
<mapping class="eu.etaxonomy.cdm.model.term.TermRelationshipType"/>
<mapping class="eu.etaxonomy.cdm.model.term.TermTree"/>
<mapping class="eu.etaxonomy.cdm.model.term.TermGraph"/>
- <mapping class="eu.etaxonomy.cdm.model.term.TermTreeNode"/>
+ <mapping class="eu.etaxonomy.cdm.model.term.TermNode"/>
<mapping class="eu.etaxonomy.cdm.model.term.TermRelation"/>
<mapping class="eu.etaxonomy.cdm.model.term.TermVocabulary"/>
BGBM BDI Projects / cdmlib.git / commitdiff