import eu.etaxonomy.cdm.model.permission.PermissionClass;\r
import eu.etaxonomy.cdm.model.reference.OriginalSourceType;\r
import eu.etaxonomy.cdm.model.reference.ReferenceType;\r
+import eu.etaxonomy.cdm.model.taxon.ConceptDefinition;\r
+import eu.etaxonomy.cdm.model.taxon.ConceptStatus;\r
import eu.etaxonomy.cdm.model.taxon.TaxonNodeStatus;\r
+import eu.etaxonomy.cdm.model.taxon.TaxonType;\r
import eu.etaxonomy.cdm.model.term.IKeyTerm;\r
import eu.etaxonomy.cdm.model.term.TermType;\r
\r
//CdmClass\r
}else if (clazz.equals(CdmClass.class)){\r
return CdmClass.getByKey(val);\r
+ //CdmClass\r
+ }else if (clazz.equals(ConceptDefinition.class)){\r
+ return ConceptDefinition.getByKey(val);\r
+ //CdmClass\r
+ }else if (clazz.equals(ConceptStatus.class)){\r
+ return ConceptStatus.getByKey(val);\r
+ //CdmClass\r
+ }else if (clazz.equals(TaxonType.class)){\r
+ return TaxonType.getByKey(val);\r
}else{\r
throw new IllegalArgumentException(String.format("EnumType %s not supported by %s.", clazz.getSimpleName(), EnumUserType.class.getSimpleName()));\r
}\r
}
}
- /**
- * EnumSets being part of the model should be immutable to make hibernate know if they have been changed.
- * Therefore any change to the enum set should result in a new enum set.
- */
- protected EnumSet<CdmClass> newEnumSet(@NotNull EnumSet<CdmClass> enumSet, CdmClass additionalClass, CdmClass classToRemove) {
- EnumSet<CdmClass> result = EnumSet.copyOf(enumSet);
- if (additionalClass != null){
- result.add(additionalClass);
- }
- if (classToRemove != null){
- result.remove(classToRemove);
- }
- return result;
- }
}
import java.beans.PropertyChangeSupport;
import java.io.Serializable;
import java.lang.reflect.Method;
+import java.util.EnumSet;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
return field;
}
+
+ /**
+ * EnumSets being part of the model should be immutable to make hibernate know if they have been changed.
+ * Therefore any change to the enum set should result in a new enum set.
+ */
+ protected <T extends Enum<T>> EnumSet<T> newEnumSet(@NotNull EnumSet<T> enumSet, T additionalClass, T classToRemove) {
+ EnumSet<T> result = EnumSet.copyOf(enumSet);
+ if (additionalClass != null){
+ result.add(additionalClass);
+ }
+ if (classToRemove != null){
+ result.remove(classToRemove);
+ }
+ return result;
+ }
+
// ********************* HELPER ****************************************/
protected <T extends CdmBase> boolean replaceInList(List<T> list,
--- /dev/null
+/**
+* Copyright (C) 2021 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.model.taxon;
+
+import java.util.EnumSet;
+import java.util.Set;
+import java.util.UUID;
+
+import javax.xml.bind.annotation.XmlEnum;
+
+import eu.etaxonomy.cdm.model.common.Language;
+import eu.etaxonomy.cdm.model.term.EnumeratedTermVoc;
+import eu.etaxonomy.cdm.model.term.IEnumTerm;
+
+/**
+ * @author a.mueller
+ * @since 10.05.2021
+ */
+@XmlEnum
+public enum ConceptDefinition
+ implements IEnumTerm<ConceptDefinition>{
+
+ HOMOTYPIC_GROUP(UUID.fromString("951d781d-f30d-4749-a79a-858a4e6a6eee"),"homotypic groups","HG"),
+ HOMOTYPIC_GROUP_WITH_EDITOR(UUID.fromString("ee316a72-fd0c-48ac-9104-0fccff091b01"),"homotypic groups with editor decisions","HGWE"),
+ DESCRIPTION(UUID.fromString("eaec1b7e-a9cd-432f-a684-9504f0e85337"),"descriptions","DES"),
+ DESCRIPTION_WITH_EDITOR(UUID.fromString("5ab7fd6e-b7c3-42b7-9a75-d3cccb547a96"),"descriptions with editor decisions","DESWE"),
+
+ ;
+ @SuppressWarnings("unchecked")
+ private ConceptDefinition(UUID uuid, String defaultString, String key){
+ delegateVocTerm = EnumeratedTermVoc.addTerm(getClass(), this, uuid, defaultString, key, null);
+ }
+
+ // *************************** DELEGATE **************************************/
+
+ private static EnumeratedTermVoc<ConceptDefinition> delegateVoc;
+ private IEnumTerm<ConceptDefinition> delegateVocTerm;
+
+ static {
+ delegateVoc = EnumeratedTermVoc.getVoc(ConceptDefinition.class);
+ }
+
+ @Override
+ public String getKey(){return delegateVocTerm.getKey();}
+
+ @Override
+ public String getLabel(){return delegateVocTerm.getLabel();}
+
+ @Override
+ public String getLabel(Language language){return delegateVocTerm.getLabel(language);}
+
+ @Override
+ public UUID getUuid() {return delegateVocTerm.getUuid();}
+
+ @Override
+ public ConceptDefinition getKindOf() {return delegateVocTerm.getKindOf();}
+
+ @Override
+ public Set<ConceptDefinition> getGeneralizationOf() {return delegateVocTerm.getGeneralizationOf();}
+
+ @Override
+ public boolean isKindOf(ConceptDefinition ancestor) {return delegateVocTerm.isKindOf(ancestor); }
+
+ @Override
+ public Set<ConceptDefinition> getGeneralizationOf(boolean recursive) {return delegateVocTerm.getGeneralizationOf(recursive);}
+
+
+ public static ConceptDefinition getByKey(String key){return delegateVoc.getByKey(key);}
+ public static ConceptDefinition getByUuid(UUID uuid) {return delegateVoc.getByUuid(uuid);}
+
+//*************************** END DELEGATE *********************************************/
+
+ protected static boolean includesType(EnumSet<ConceptDefinition> set, ConceptDefinition definition) {
+ EnumSet<ConceptDefinition> all;
+ if (definition.getGeneralizationOf(true).isEmpty()){
+ all = EnumSet.noneOf(ConceptDefinition.class);
+ }else{
+ all = EnumSet.copyOf(definition.getGeneralizationOf(true));
+ }
+ all.add(definition);
+ for (ConceptDefinition def : all){
+ if (set.contains(def)){
+ return true;
+ }
+ }
+ return false;
+ }
+}
--- /dev/null
+/**
+* Copyright (C) 2021 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.model.taxon;
+
+import java.util.EnumSet;
+import java.util.Set;
+import java.util.UUID;
+
+import javax.xml.bind.annotation.XmlEnum;
+
+import eu.etaxonomy.cdm.model.common.Language;
+import eu.etaxonomy.cdm.model.term.EnumeratedTermVoc;
+import eu.etaxonomy.cdm.model.term.IEnumTerm;
+
+/**
+ * @author a.mueller
+ * @since 10.05.2021
+ */
+@XmlEnum
+public enum ConceptStatus
+ implements IEnumTerm<ConceptStatus>{
+
+ PERSISTENT(UUID.fromString("08ae05a9-2d61-4c6d-b005-5d47d0139eff"),"persistent","PER"),
+ SUPPORTS_PROVENANCE(UUID.fromString("1f0417cb-72ae-4a0e-a2fa-cce0de2c462a"),"supports provenance","PRO"),
+ CURRENT(UUID.fromString("fba936d3-e871-4993-b29c-20a846a112d7"),"current","CUR")
+
+ ;
+ @SuppressWarnings("unchecked")
+ private ConceptStatus(UUID uuid, String defaultString, String key){
+ delegateVocTerm = EnumeratedTermVoc.addTerm(getClass(), this, uuid, defaultString, key, null);
+ }
+
+ // *************************** DELEGATE **************************************/
+
+ private static EnumeratedTermVoc<ConceptStatus> delegateVoc;
+ private IEnumTerm<ConceptStatus> delegateVocTerm;
+
+ static {
+ delegateVoc = EnumeratedTermVoc.getVoc(ConceptStatus.class);
+ }
+
+ @Override
+ public String getKey(){return delegateVocTerm.getKey();}
+
+ @Override
+ public String getLabel(){return delegateVocTerm.getLabel();}
+
+ @Override
+ public String getLabel(Language language){return delegateVocTerm.getLabel(language);}
+
+ @Override
+ public UUID getUuid() {return delegateVocTerm.getUuid();}
+
+ @Override
+ public ConceptStatus getKindOf() {return delegateVocTerm.getKindOf();}
+
+ @Override
+ public Set<ConceptStatus> getGeneralizationOf() {return delegateVocTerm.getGeneralizationOf();}
+
+ @Override
+ public boolean isKindOf(ConceptStatus ancestor) {return delegateVocTerm.isKindOf(ancestor); }
+
+ @Override
+ public Set<ConceptStatus> getGeneralizationOf(boolean recursive) {return delegateVocTerm.getGeneralizationOf(recursive);}
+
+
+ public static ConceptStatus getByKey(String key){return delegateVoc.getByKey(key);}
+ public static ConceptStatus getByUuid(UUID uuid) {return delegateVoc.getByUuid(uuid);}
+
+//*************************** END DELEGATE *********************************************/
+
+ protected static boolean includesType(EnumSet<ConceptStatus> set, ConceptStatus status) {
+ EnumSet<ConceptStatus> all;
+ if (status.getGeneralizationOf(true).isEmpty()){
+ all = EnumSet.noneOf(ConceptStatus.class);
+ }else{
+ all = EnumSet.copyOf(status.getGeneralizationOf(true));
+ }
+ all.add(status);
+ for (ConceptStatus st : all){
+ if (set.contains(st)){
+ return true;
+ }
+ }
+ return false;
+ }
+}
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
+import java.util.EnumSet;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import org.apache.log4j.Logger;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
+import org.hibernate.annotations.Type;
import org.hibernate.envers.Audited;
import org.hibernate.search.annotations.ClassBridge;
import org.hibernate.search.annotations.ClassBridges;
import eu.etaxonomy.cdm.hibernate.search.GroupByTaxonClassBridge;
import eu.etaxonomy.cdm.hibernate.search.TaxonRelationshipClassBridge;
import eu.etaxonomy.cdm.model.common.CdmBase;
+import eu.etaxonomy.cdm.model.common.CdmClass;
import eu.etaxonomy.cdm.model.common.IRelated;
import eu.etaxonomy.cdm.model.common.RelationshipBase;
+import eu.etaxonomy.cdm.model.common.TimePeriod;
import eu.etaxonomy.cdm.model.description.DescriptionElementBase;
import eu.etaxonomy.cdm.model.description.DescriptionType;
import eu.etaxonomy.cdm.model.description.Feature;
"synonyms",
"relationsFromThisTaxon",
"relationsToThisTaxon",
- "descriptions"
+ "descriptions",
+ "conceptId",
+ "conceptDefinitions",
+ "conceptStatus",
+ "taxonTypes",
+ "currentConceptPeriod"
})
@XmlRootElement(name = "Taxon")
@Entity
@IndexedEmbedded
private Set<TaxonNode> taxonNodes = new HashSet<>();
+ private String conceptId;
+
+ @XmlAttribute(name ="TaxonType")
+ @NotNull
+ @Type(type = "eu.etaxonomy.cdm.hibernate.EnumSetUserType",
+ parameters = {@org.hibernate.annotations.Parameter(name="enumClass", value="eu.etaxonomy.cdm.model.taxon.TaxonType")}
+ )
+ @Audited
+ private EnumSet<TaxonType> taxonTypes = EnumSet.noneOf(TaxonType.class);
+
+ @XmlAttribute(name ="ConceptDefinition")
+ @NotNull
+ @Type(type = "eu.etaxonomy.cdm.hibernate.EnumSetUserType",
+ parameters = {@org.hibernate.annotations.Parameter(name="enumClass", value="eu.etaxonomy.cdm.model.taxon.ConceptDefinition")}
+ )
+ @Audited
+ private EnumSet<ConceptDefinition> conceptDefinitions = EnumSet.noneOf(ConceptDefinition.class);
+
+ @XmlAttribute(name ="ConceptStatus")
+ @NotNull
+ @Type(type = "eu.etaxonomy.cdm.hibernate.EnumSetUserType",
+ parameters = {@org.hibernate.annotations.Parameter(name="enumClass", value="eu.etaxonomy.cdm.model.taxon.ConceptStatus")}
+ )
+ @Audited
+ private EnumSet<ConceptStatus> conceptStatus = EnumSet.noneOf(ConceptStatus.class);
+
+ private TimePeriod currentConceptPeriod = TimePeriod.NewInstance();
+
// ************************* FACTORY METHODS ********************************/
/**
//********* METHODS **************************************/
+ public String getConceptId() {
+ return conceptId;
+ }
+ public void setConceptId(String conceptId) {
+ this.conceptId = conceptId;
+ }
+
+ public TimePeriod getCurrentConceptPeriod() {
+ return currentConceptPeriod;
+ }
+ public void setCurrentConceptPeriod(TimePeriod currentConceptPeriod) {
+ this.currentConceptPeriod = currentConceptPeriod;
+ }
+
+// ************************ Concept Defintion ************************/
+
+ public boolean isHomotypicGroups() {
+ return ConceptDefinition.includesType(conceptDefinitions, ConceptDefinition.HOMOTYPIC_GROUP);
+ }
+ public void setHomotypicGroups(boolean isHomotypicGroups) {
+ setConceptDefinition(ConceptDefinition.HOMOTYPIC_GROUP, isHomotypicGroups);
+ }
+
+ //calling it descriptionConcept not Descriptions to avoid name clash with setter for TaxonDescriptions
+ public boolean isDescriptionConcept() {
+ return ConceptDefinition.includesType(conceptDefinitions, ConceptDefinition.DESCRIPTION);
+ }
+ public void setDescriptionConcept(boolean isDescriptions) {
+ setConceptDefinition(ConceptDefinition.DESCRIPTION, isDescriptions);
+ }
+
+ protected EnumSet<ConceptDefinition> getConceptDefinition() {
+ return conceptDefinitions;
+ }
+
+ /**
+ * for know it is private and the boolean getters and setters should be used instead.
+ * If you make it public make sure to guarantee that any change to the enum set results
+ * in a new enum set (see also {@link #newEnumSet(EnumSet, ConceptDefinition, ConceptDefinition)}
+ * and that the client is aware of the enum set being immutable.
+ */
+ private void setConceptDefinitions(EnumSet<ConceptDefinition> conceptDefinitions){
+ this.conceptDefinitions = conceptDefinitions;
+ }
+
+ /**
+ * Sets the value for taxon concept definitions
+ * @param conceptDefinition the concept definition
+ * @param value the value if this taxon has this concept definition (<code>true</code>) or not (<code>false</code>)
+ */
+ protected void setConceptDefinition(ConceptDefinition conceptDefinition, boolean value) {
+ if (value && !this.conceptDefinitions.contains(conceptDefinition)){
+ setConceptDefinitions(newEnumSet(this.conceptDefinitions, conceptDefinition, null));
+ }else if (!value && this.conceptDefinitions.contains(conceptDefinition)){
+ setConceptDefinitions(newEnumSet(this.conceptDefinitions, null, conceptDefinition));
+ }else{
+ return;
+ }
+ }
+
+// ************************ TaxonType ********************************/
+
+ public boolean isConcept() {
+ return TaxonType.includesType(taxonTypes, TaxonType.CONCEPT);
+ }
+ public void setConcept(boolean isConcept) {
+ setTaxonType(TaxonType.CONCEPT, isConcept);
+ }
+
+ public boolean isNameUsage() {
+ return TaxonType.includesType(taxonTypes, TaxonType.NAME_USAGE);
+ }
+ public void setNameUsage(boolean isNameUsage) {
+ setTaxonType(TaxonType.NAME_USAGE, isNameUsage);
+ }
+
+ protected EnumSet<TaxonType> getTaxonTypes() {
+ return taxonTypes;
+ }
+
+ /**
+ * for know it is private and the boolean getters and setters should be used instead.
+ * If you make it public make sure to guarantee that any change to the enum set results
+ * in a new enum set (see also {@link #newEnumSet(EnumSet, TaxonType, TaxonType)}
+ * and that the client is aware of the enum set being immutable.
+ */
+ private void setTaxonTypes(EnumSet<TaxonType> taxonTypes){
+ this.taxonTypes = taxonTypes;
+ }
+
+ /**
+ * Sets the value for taxon types
+ * @param type the taxon type
+ * @param value the value if this taxon has this type (<code>true</code>) or not (<code>false</code>)
+ */
+ protected void setTaxonType(TaxonType type, boolean value) {
+ if (value && !this.taxonTypes.contains(type)){
+ setTaxonTypes(newEnumSet(this.taxonTypes, type, null));
+ }else if (!value && this.taxonTypes.contains(type)){
+ setTaxonTypes(newEnumSet(this.taxonTypes, null, type));
+ }else{
+ return;
+ }
+ }
+
+// ************************ Concept Status ********************************/
+
+ public boolean isPersistent() {
+ return ConceptStatus.includesType(conceptStatus, ConceptStatus.PERSISTENT);
+ }
+ public void setPersistent(boolean isPersistent) {
+ setConceptStatus(ConceptStatus.PERSISTENT, isPersistent);
+ }
+ public boolean isSupportsProvenance() {
+ return ConceptStatus.includesType(conceptStatus, ConceptStatus.SUPPORTS_PROVENANCE);
+ }
+ public void setSupportsProvenance(boolean isSupportsProvenance) {
+ setConceptStatus(ConceptStatus.SUPPORTS_PROVENANCE, isSupportsProvenance);
+ }
+ public boolean isCurrentConcept() {
+ return ConceptStatus.includesType(conceptStatus, ConceptStatus.CURRENT);
+ }
+ public void setCurrentConcept(boolean isCurrentConcept) {
+ setConceptStatus(ConceptStatus.CURRENT, isCurrentConcept);
+ }
+
+ protected EnumSet<ConceptStatus> getConceptStatus() {
+ return conceptStatus;
+ }
+
+ /**
+ * for know it is private and the boolean getters and setters should be used instead.
+ * If you make it public make sure to guarantee that any change to the enum set results
+ * in a new enum set (see also {@link #newEnumSet(EnumSet, CdmClass, CdmClass)}
+ * and that the client is aware of the enum set being immutable.
+ */
+ private void setConceptStatus(EnumSet<ConceptStatus> conceptStatus){
+ this.conceptStatus = conceptStatus;
+ }
+
+ /**
+ * Sets the value for concept status
+ * @param conceptStatus the concept status
+ * @param value the value if this concept has this status (<code>true</code>) or not (<code>false</code>)
+ */
+ protected void setConceptStatus(ConceptStatus conceptStatus, boolean value) {
+ if (value && !this.conceptStatus.contains(conceptStatus)){
+ setConceptStatus(newEnumSet(this.conceptStatus, conceptStatus, null));
+ }else if (!value && this.conceptStatus.contains(conceptStatus)){
+ setConceptStatus(newEnumSet(this.conceptStatus, null, conceptStatus));
+ }else{
+ return;
+ }
+ }
+
+// ****************************************************************/
+
/**
* Returns the set of {@link eu.etaxonomy.cdm.model.description.TaxonDescription taxon descriptions}
* concerning <i>this</i> taxon.
result.addTaxonNode(newTaxonNode);
}*/
+
+ //concept related attributes
+ result.taxonTypes = this.taxonTypes.clone();
+ result.conceptDefinitions = this.conceptDefinitions.clone();
+ result.conceptStatus = this.conceptStatus.clone();
+
+ if (this.currentConceptPeriod != null){
+ result.currentConceptPeriod = this.currentConceptPeriod.clone();
+ }
+
return result;
}
+
}
--- /dev/null
+/**
+* Copyright (C) 2021 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.model.taxon;
+
+import java.util.EnumSet;
+import java.util.Set;
+import java.util.UUID;
+
+import javax.xml.bind.annotation.XmlEnum;
+
+import eu.etaxonomy.cdm.model.common.Language;
+import eu.etaxonomy.cdm.model.term.EnumeratedTermVoc;
+import eu.etaxonomy.cdm.model.term.IEnumTerm;
+
+/**
+ * @author a.mueller
+ * @since 10.05.2021
+ */
+@XmlEnum
+public enum TaxonType
+ implements IEnumTerm<TaxonType>{
+ CONCEPT(UUID.fromString("d6e65c50-729a-4c80-8ec0-d30627c8b2f0"), "Concept","CO"),
+ NAME_USAGE(UUID.fromString("a3ffccb8-8408-4fb4-8e38-9ffe84ca804f"), "Name Usage","NU"),
+ ;
+
+ @SuppressWarnings("unchecked")
+ private TaxonType(UUID uuid, String defaultString, String key){
+ delegateVocTerm = EnumeratedTermVoc.addTerm(getClass(), this, uuid, defaultString, key, null);
+ }
+
+ // *************************** DELEGATE **************************************/
+
+ private static EnumeratedTermVoc<TaxonType> delegateVoc;
+ private IEnumTerm<TaxonType> delegateVocTerm;
+
+ static {
+ delegateVoc = EnumeratedTermVoc.getVoc(TaxonType.class);
+ }
+
+ @Override
+ public String getKey(){return delegateVocTerm.getKey();}
+
+ @Override
+ public String getLabel(){return delegateVocTerm.getLabel();}
+
+ @Override
+ public String getLabel(Language language){return delegateVocTerm.getLabel(language);}
+
+ @Override
+ public UUID getUuid() {return delegateVocTerm.getUuid();}
+
+ @Override
+ public TaxonType getKindOf() {return delegateVocTerm.getKindOf();}
+
+ @Override
+ public Set<TaxonType> getGeneralizationOf() {return delegateVocTerm.getGeneralizationOf();}
+
+ @Override
+ public boolean isKindOf(TaxonType ancestor) {return delegateVocTerm.isKindOf(ancestor); }
+
+ @Override
+ public Set<TaxonType> getGeneralizationOf(boolean recursive) {return delegateVocTerm.getGeneralizationOf(recursive);}
+
+ public static TaxonType getByKey(String key){return delegateVoc.getByKey(key);}
+ public static TaxonType getByUuid(UUID uuid) {return delegateVoc.getByUuid(uuid);}
+
+//*************************** END DELEGATE *********************************************/
+
+ protected static boolean includesType(EnumSet<TaxonType> set, TaxonType type) {
+ EnumSet<TaxonType> all;
+ if (type.getGeneralizationOf(true).isEmpty()){
+ all = EnumSet.noneOf(TaxonType.class);
+ }else{
+ all = EnumSet.copyOf(type.getGeneralizationOf(true));
+ }
+ all.add(type);
+ for (TaxonType st : all){
+ if (set.contains(st)){
+ return true;
+ }
+ }
+ return false;
+ }
+}
}
private void createTaxon(List<CdmBase> cdmBases) {
+
Reference sec = getReference();
TaxonName name = TaxonNameFactory.NewBotanicalInstance(Rank.GENUS());
Taxon taxon = Taxon.NewInstance(name, sec);
sec, "444");
taxon.setTaxonStatusUnknown(true);
handleAnnotatableEntity(taxRel);
+ concept.setConcept(true);
+ concept.setNameUsage(true);
+ concept.setHomotypicGroups(true);
+ concept.setConceptId("euromed123");
+ concept.setPersistent(true);
+ concept.setCurrentConceptPeriod(TimePeriod.NewInstance(1999, 2019));
+ concept.setSupportsProvenance(true);
//Classification
Classification classification = Classification.NewInstance("My classification", sec);
import org.apache.log4j.Logger;
+import eu.etaxonomy.cdm.database.update.ColumnAdder;
import eu.etaxonomy.cdm.database.update.ColumnRemover;
import eu.etaxonomy.cdm.database.update.ISchemaUpdater;
import eu.etaxonomy.cdm.database.update.ISchemaUpdaterStep;
+ " WHERE name = 'Editor-Reference'";
SimpleSchemaUpdaterStep.NewNonAuditedInstance(stepList, stepName, query, -99);
+ //#9619
+ stepName = "Add Taxon.conceptId";
+ tableName = "TaxonBase";
+ newColumnName = "conceptId";
+ ColumnAdder.NewStringInstance(stepList, stepName, tableName, newColumnName, INCLUDE_AUDIT);
+
+
+ //#9619
+ stepName = "Add Taxon.conceptDefinitions";
+ tableName = "TaxonBase";
+ newColumnName = "conceptDefinitions";
+ ColumnAdder.NewStringInstance(stepList, stepName, tableName, newColumnName, INCLUDE_AUDIT);
+
+ //#9619
+ stepName = "Add Taxon.conceptStatus";
+ tableName = "TaxonBase";
+ newColumnName = "conceptStatus";
+ ColumnAdder.NewStringInstance(stepList, stepName, tableName, newColumnName, INCLUDE_AUDIT);
+
+ //#9619
+ stepName = "Add Taxon.taxonTypes";
+ tableName = "TaxonBase";
+ newColumnName = "taxonTypes";
+ ColumnAdder.NewStringInstance(stepList, stepName, tableName, newColumnName, INCLUDE_AUDIT);
+
+ //#9619
+ stepName = "Add Taxon.currentConceptPeriod_start";
+ tableName = "TaxonBase";
+ newColumnName = "currentConceptPeriod_start";
+ ColumnAdder.NewStringInstance(stepList, stepName, tableName, newColumnName, INCLUDE_AUDIT);
+
+ stepName = "Add Taxon.currentConceptPeriod_end";
+ tableName = "TaxonBase";
+ newColumnName = "currentConceptPeriod_end";
+ ColumnAdder.NewStringInstance(stepList, stepName, tableName, newColumnName, INCLUDE_AUDIT);
+
+ stepName = "Add Taxon.currentConceptPeriod_freetext";
+ tableName = "TaxonBase";
+ newColumnName = "currentConceptPeriod_freetext";
+ ColumnAdder.NewStringInstance(stepList, stepName, tableName, newColumnName, INCLUDE_AUDIT);
+
return stepList;
}
DOUBTFUL boolean not null,
PUBLISH boolean not null,
USENAMECACHE boolean not null,
+ CONCEPTDEFINITIONS varchar(255),
+ CONCEPTID varchar(255),
+ CONCEPTSTATUS varchar(255),
+ CURRENTCONCEPTPERIOD_END varchar(255),
+ CURRENTCONCEPTPERIOD_FREETEXT varchar(255),
+ CURRENTCONCEPTPERIOD_START varchar(255),
TAXONSTATUSUNKNOWN boolean,
+ TAXONTYPES varchar(255),
CREATEDBY_ID integer,
UPDATEDBY_ID integer,
NAME_ID integer,
CREATEDBY_ID integer,
UPDATEDBY_ID integer,
NAME_ID integer,
+ CONCEPTDEFINITIONS varchar(255),
+ CONCEPTID varchar(255),
+ CONCEPTSTATUS varchar(255),
+ CURRENTCONCEPTPERIOD_END varchar(255),
+ CURRENTCONCEPTPERIOD_FREETEXT varchar(255),
+ CURRENTCONCEPTPERIOD_START varchar(255),
TAXONSTATUSUNKNOWN boolean,
+ TAXONTYPES varchar(255),
ACCEPTEDTAXON_ID integer,
TYPE_ID integer,
primary key (ID, REV)
BGBM BDI Projects / cdmlib.git / commitdiff