cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/metadata/CdmMetaData.java

   1 /**
   2 * Copyright (C) 2007 EDIT
   3 * European Distributed Institute of Taxonomy
   4 * http://www.e-taxonomy.eu
   5 *
   6 * The contents of this file are subject to the Mozilla Public License Version 1.1
   7 * See LICENSE.TXT at the top of this package for the full license terms.
   8 */
   9
  10 package eu.etaxonomy.cdm.model.metadata;
  11
  12 import java.util.ArrayList;
  13 import java.util.Comparator;
  14 import java.util.List;
  15 import java.util.UUID;
  16
  17 import javax.persistence.Column;
  18 import javax.persistence.Entity;
  19 import javax.validation.constraints.NotNull;
  20 import javax.xml.bind.annotation.XmlAttribute;
  21
  22 import org.apache.log4j.Logger;
  23 import org.hibernate.annotations.Type;
  24 import org.joda.time.DateTime;
  25
  26 import eu.etaxonomy.cdm.common.monitor.IProgressMonitor;
  27 import eu.etaxonomy.cdm.model.common.CdmBase;
  28 import eu.etaxonomy.cdm.model.term.DefinedTermBase;
  29 import eu.etaxonomy.cdm.model.term.TermType;
  30 import eu.etaxonomy.cdm.model.term.TermVocabulary;
  31
  32 /**
  33  * @author a.mueller
  34  * @since 07.09.2009
  35  */
  36 @Entity
  37 public class CdmMetaData extends CdmBase{
  38
  39     private static final long serialVersionUID = -3033376680593279078L;
  40         @SuppressWarnings("unused")
  41         private static final Logger logger = Logger.getLogger(CdmMetaData.class);
  42
  43         private static final String UNNAMED = "- UNNAMED -";
  44
  45         /**
  46          * The database schema version number.
  47          * It is recommended to have the first two numbers equal to the CDM Library version number.
  48          * But it is not obligatory as there may be cases when the library number changes but the
  49          * schema version is not changing.
  50          * The third should be incremented if the schema changes in a way that SCHEMA_VALIDATION.UPDATE
  51          * will probably not work or will not be enough to transform old data into new data.
  52          * The fourth number should be incremented when minor schema changes take place that can
  53          * be handled by SCHEMA_VALIDATION.UPDATE
  54          * The last number represents the date of change.
  55          */
  56         private static final String dbSchemaVersion = CdmVersion.V_05_25_00.versionString;
  57
  58         public enum CdmVersion {
  59             V_05_12_00("5.12.0.0.20191202"),
  60         V_05_15_00("5.15.0.0.20200510"),
  61             V_05_15_01("5.15.1.0.20200610"),
  62             V_05_15_02("5.15.2.0.20200611"),
  63             V_05_18_00("5.18.0.0.20200902"),
  64         V_05_18_01("5.18.1.0.20200914"),
  65         V_05_18_02("5.18.2.0.20200921"),
  66         V_05_18_03("5.18.3.0.20200924"),
  67         V_05_18_04("5.18.4.0.20201020"),
  68         V_05_18_05("5.18.5.0.20201103"),
  69         V_05_18_06("5.18.6.0.20201124"),
  70         V_05_22_00("5.22.0.0.20210315"),
  71         V_05_23_00("5.23.0.0.20210422"),
  72         V_05_25_00("5.25.0.0.20210609")
  73         ;
  74         private String versionString;
  75             private CdmVersion(String versionString){
  76                 this.versionString = versionString;
  77             }
  78             public String versionString(){
  79                 return versionString;
  80             }
  81         }
  82
  83         /**
  84      * The {@link TermType type} of this term. Needs to be the same type in a {@link DefinedTermBase defined term}
  85      * and in it's {@link TermVocabulary vocabulary}.
  86      */
  87     @XmlAttribute(name ="PropertyName")
  88     @Column(name="propertyName", length=20)
  89     @NotNull
  90     @Type(type = "eu.etaxonomy.cdm.hibernate.EnumUserType",
  91         parameters = {@org.hibernate.annotations.Parameter(name = "enumClass", value = "eu.etaxonomy.cdm.model.metadata.CdmMetaDataPropertyName")}
  92     )
  93         private CdmMetaDataPropertyName propertyName;
  94         private String value;
  95
  96
  97 //********************* Constructor *********************************************/
  98
  99         /**
 100          * Simple constructor to be used by Spring
 101          */
 102         protected CdmMetaData(){
 103                 super();
 104         }
 105
 106         public CdmMetaData(CdmMetaDataPropertyName propertyName, String value) {
 107                 super();
 108                 this.propertyName = propertyName;
 109                 this.value = value;
 110         }
 111
 112 // ******************** STATIC **********************************/
 113
 114     /**
 115      * @return a list of default metadata objects
 116      */
 117     public static final List<CdmMetaData> defaultMetaData(){
 118         List<CdmMetaData> result = new ArrayList<>();
 119         // schema version
 120         result.add(new CdmMetaData(CdmMetaDataPropertyName.DB_SCHEMA_VERSION, dbSchemaVersion));
 121         // database create time
 122         result.add(new CdmMetaData(CdmMetaDataPropertyName.DB_CREATE_DATE, new DateTime().toString()));
 123         result.add(new CdmMetaData(CdmMetaDataPropertyName.INSTANCE_ID, UUID.randomUUID().toString()));
 124         result.add(new CdmMetaData(CdmMetaDataPropertyName.INSTANCE_NAME, UNNAMED));
 125         return result;
 126     }
 127
 128 //****************** instance methods ****************************/
 129
 130         public CdmMetaDataPropertyName getPropertyName() {
 131                 return propertyName;
 132         }
 133         public void setPropertyName(CdmMetaDataPropertyName propertyName) {
 134                 this.propertyName = propertyName;
 135         }
 136
 137         public String getValue() {
 138                 return value;
 139         }
 140         public void setValue(String value) {
 141                 this.value = value;
 142         }
 143
 144 //******************** Version comparator **********************************/
 145
 146         public static class VersionComparator implements Comparator<String>{
 147                 Integer depth;
 148                 IProgressMonitor monitor;
 149
 150                 public VersionComparator(Integer depth, IProgressMonitor monitor){
 151                         this.depth = depth;
 152                         this.monitor = monitor;
 153                 }
 154
 155                 @Override
 156         public int compare(String version1, String version2) {
 157                         int result = 0;
 158
 159                         if (version1.equals(version2)){
 160                             return 0;
 161                         }
 162
 163                         String[] version1Split = version1.split("\\.");
 164                         String[] version2Split = version2.split("\\.");
 165
 166                         if(version1Split.length == 1 || version2Split.length == 1){
 167                                 throwException("Tried to compare version but given Strings don't seem to " +
 168                                                 "contain version numbers. version1: " + version1 + ", version2:" + version2);
 169                         }
 170
 171                         if(depth != null && (version1Split.length < depth || version2Split.length < depth )){
 172                                 throwException("Desired depth can not be achieved with the given strings. depth: " + depth  + ", version1: " + version1 + ", version2:" + version2);
 173                         }
 174                         //use the shorter version to avoid arrayOutOfBoundsException, if version2Split.length < version1Split.length but > depth
 175                         int length = (version1Split.length < version2Split.length) ? version1Split.length: version2Split.length;
 176                         if (depth != null){
 177                             length = length<depth?length:depth;
 178                         }
 179                         for (int i = 0; i < length; i++){
 180                                 Long version1Part = Long.valueOf(version1Split[i]);
 181                                 Long version2Part = Long.valueOf(version2Split[i]);
 182                                 int partCompare = version1Part.compareTo(version2Part);
 183                                 if (partCompare != 0){
 184                                         return partCompare;
 185                                 }
 186                         }
 187                         return result;
 188                 }
 189
 190                 private Throwable throwException(String message){
 191                         RuntimeException exception =  new RuntimeException(message);
 192                         if (monitor != null){
 193                                 monitor.warning(message, exception);
 194                         }
 195                         throw exception;
 196                 }
 197         }
 198
 199         /**
 200          * Compares two version string. If version1 is higher than version2 a positive result is returned.
 201          * If both are equal 0 is returned, otherwise -1 is returned.
 202          * @see Comparator#compare(Object, Object)
 203          * @return
 204          */
 205         public static int compareVersion(String version1, String version2, Integer depth, IProgressMonitor monitor){
 206                 VersionComparator versionComparator = new VersionComparator(depth, monitor);
 207                 return versionComparator.compare(version1, version2);
 208         }
 209
 210         public static boolean isDbSchemaVersionCompatible(String version){
 211                 return compareVersion(dbSchemaVersion, version, 3, null) == 0;
 212         }
 213
 214         public static String getDbSchemaVersion() {
 215                 return dbSchemaVersion;
 216         }
 217 }