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

   1 // $Id$
   2 /**
   3 * Copyright (C) 2007 EDIT
   4 * European Distributed Institute of Taxonomy
   5 * http://www.e-taxonomy.eu
   6 *
   7 * The contents of this file are subject to the Mozilla Public License Version 1.1
   8 * See LICENSE.TXT at the top of this package for the full license terms.
   9 */
  10
  11 package eu.etaxonomy.cdm.model.metadata;
  12
  13 import java.util.ArrayList;
  14 import java.util.Comparator;
  15 import java.util.List;
  16
  17 import javax.persistence.Entity;
  18
  19 import org.apache.log4j.Logger;
  20 import org.joda.time.DateTime;
  21
  22 import eu.etaxonomy.cdm.common.monitor.IProgressMonitor;
  23 import eu.etaxonomy.cdm.model.common.CdmBase;
  24
  25 /**
  26  * @author a.mueller
  27  * @created 07.09.2009
  28  */
  29 @Entity
  30 public class CdmMetaData extends CdmBase{
  31         private static final long serialVersionUID = -3033376680593279078L;
  32         @SuppressWarnings("unused")
  33         private static final Logger logger = Logger.getLogger(CdmMetaData.class);
  34
  35         /* It is a little bit confusing that this specific information is located in
  36          * a generic class for metadata. Think about moving the schema version
  37          *
  38          */
  39         /**
  40          * The database schema version number.
  41          * It is recommended to have the first two numbers equal to the CDM Library version number.
  42          * But it is not obligatory as there may be cases when the library number changes but the
  43          * schema version is not changing.
  44          * The third should be incremented if the schema changes in a way that SCHEMA_VALIDATION.UPDATE
  45          * will probably not work or will not be enough to transform old data into new data.
  46          * The fourth number should be incremented when minor schema changes take place that can
  47          * be handled by SCHEMA_VALIDATION.UPDATE
  48          * The last number represents the date of change.
  49          */
  50 //      private static final String dbSchemaVersion = "3.3.1.0.201401140000";
  51         private static final String dbSchemaVersion = "3.4.0.0.201407010000";
  52
  53
  54
  55
  56         /**
  57          * @return a list of default metadata objects
  58          */
  59         public static final List<CdmMetaData> defaultMetaData(){
  60                 List<CdmMetaData> result = new ArrayList<CdmMetaData>();
  61                 // schema version
  62                 result.add(new CdmMetaData(MetaDataPropertyName.DB_SCHEMA_VERSION, dbSchemaVersion));
  63                 //term version
  64                 result.add(new CdmMetaData(MetaDataPropertyName.TERMS_VERSION, termsVersion));
  65                 // database create time
  66                 result.add(new CdmMetaData(MetaDataPropertyName.DB_CREATE_DATE, new DateTime().toString()));
  67                 return result;
  68         }
  69
  70         /**
  71          * The version number for the terms loaded by the termloader (csv-files)
  72          * It is recommended to have the first two numbers equal to the CDM Library version number.
  73          *
  74          * But it is not obligatory as there may be cases when the library number changes but the
  75          * schema version is not changing.
  76          *
  77          * The third should be incremented if the terms change in a way that is not compatible
  78          * to the previous version (e.g. by changing the type of a term)
  79          *
  80          * The fourth number should be incremented when compatible term changes take place
  81          * (e.g. when new terms were added)
  82          *
  83          * The last number represents the date of change.
  84          */
  85 //      private static final String termsVersion = "3.3.0.0.201309010000";
  86         private static final String termsVersion = "3.4.0.0.201407010000";
  87
  88
  89         public enum MetaDataPropertyName{
  90                 DB_SCHEMA_VERSION,
  91                 TERMS_VERSION,
  92                 DB_CREATE_DATE,
  93                 DB_CREATE_NOTE;
  94
  95                 public String getSqlQuery(){
  96                         return "SELECT value FROM CdmMetaData WHERE propertyname=" + this.ordinal();
  97                 }
  98         }
  99
 100         /* END OF CONFUSION */
 101         private MetaDataPropertyName propertyName;
 102         private String value;
 103
 104
 105         /**
 106          * Method to retrieve a CDM Libraries meta data
 107          * @return
 108          */
 109         public static final List<CdmMetaData> propertyList(){
 110                 List<CdmMetaData> result = new ArrayList<CdmMetaData>();
 111                 result.add(new CdmMetaData(MetaDataPropertyName.DB_SCHEMA_VERSION, dbSchemaVersion));
 112                 result.add(new CdmMetaData(MetaDataPropertyName.TERMS_VERSION, termsVersion));
 113                 result.add(new CdmMetaData(MetaDataPropertyName.DB_CREATE_DATE, new DateTime().toString()));
 114                 return result;
 115         }
 116
 117 //********************* Constructor *********************************************/
 118
 119         /**
 120          * Simple constructor to be used by Spring
 121          */
 122         protected CdmMetaData(){
 123                 super();
 124         }
 125
 126         public CdmMetaData(MetaDataPropertyName propertyName, String value) {
 127                 super();
 128                 this.propertyName = propertyName;
 129                 this.value = value;
 130         }
 131
 132 //****************** instance methods ****************************************/
 133
 134         /**
 135          * @return the propertyName
 136          */
 137         public MetaDataPropertyName getPropertyName() {
 138                 return propertyName;
 139         }
 140
 141         /**
 142          * @param propertyName the propertyName to set
 143          */
 144         public void setPropertyName(MetaDataPropertyName propertyName) {
 145                 this.propertyName = propertyName;
 146         }
 147
 148         /**
 149          * @return the value
 150          */
 151         public String getValue() {
 152                 return value;
 153         }
 154
 155         /**
 156          * @param value the value to set
 157          */
 158         public void setValue(String value) {
 159                 this.value = value;
 160         }
 161
 162 //******************** Version comparator **********************************/
 163
 164         public static class VersionComparator implements Comparator<String>{
 165                 Integer depth;
 166                 IProgressMonitor monitor;
 167
 168                 public VersionComparator(Integer depth, IProgressMonitor monitor){
 169                         this.depth = depth;
 170                         this.monitor = monitor;
 171                 }
 172
 173                 /* (non-Javadoc)
 174                  * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object)
 175                  */
 176                 public int compare(String version1, String version2) {
 177                         int result = 0;
 178                         String[] version1Split = version1.split("\\.");
 179                         String[] version2Split = version2.split("\\.");
 180
 181                         if(version1Split.length == 1 || version2Split.length == 1){
 182                                 throwException("Tried to compare version but given Strings don't seem to " +
 183                                                 "contain version numbers. version1: " + version1 + ", version2:" + version2);
 184                         }
 185
 186                         if(depth != null && (version1Split.length < depth || version2Split.length < depth )){
 187                                 throwException("Desired depth can not be achieved with the given strings. depth: " + depth  + ", version1: " + version1 + ", version2:" + version2);
 188                         }
 189
 190                         int length = (depth == null ||version1Split.length < depth) ? version1Split.length : depth;
 191                         for (int i = 0; i < length; i++){
 192                                 Long version1Part = Long.valueOf(version1Split[i]);
 193                                 Long version2Part = Long.valueOf(version2Split[i]);
 194                                 int partCompare = version1Part.compareTo(version2Part);
 195                                 if (partCompare != 0){
 196                                         return partCompare;
 197                                 }
 198                         }
 199                         return result;
 200                 }
 201
 202                 private Throwable throwException(String message){
 203                         RuntimeException exception =  new RuntimeException(message);
 204                         if (monitor != null){
 205                                 monitor.warning(message, exception);
 206                         }
 207                         throw exception;
 208                 }
 209
 210         }
 211
 212         /**
 213          * Compares two version string. If version1 is higher than version2 a positive result is returned.
 214          * If both are equal 0 is returned, otherwise -1 is returned.
 215          * @see Comparator#compare(Object, Object)
 216          * @param version1
 217          * @param version2
 218          * @param depth
 219          * @param monitor
 220          * @return
 221          */
 222         public static int compareVersion(String version1, String version2, Integer depth, IProgressMonitor monitor){
 223                 VersionComparator versionComparator = new VersionComparator(depth, monitor);
 224                 return versionComparator.compare(version1, version2);
 225         }
 226
 227         public static boolean isDbSchemaVersionCompatible(String version){
 228                 return compareVersion(dbSchemaVersion, version, 3, null) == 0;
 229         }
 230
 231         public static String getDbSchemaVersion() {
 232                 return dbSchemaVersion;
 233         }
 234
 235         public static String getTermsVersion() {
 236                 return termsVersion;
 237         }
 238
 239         public static boolean isTermsVersionCompatible(String version){
 240                 return compareVersion(termsVersion, version, 3, null) == 0;
 241         }
 242
 243 }