Changeset 487 for trunk/grails-app/domain

Timestamp:

May 27, 2010, 4:03:31 PM (13 years ago)

Author:

roberth

Message:

Added net RELTIME template field type to contain relative times (e.g. 1d 3h). The type has been added as template type, but will probably not be rendered correctly yet.

Location:

trunk/grails-app/domain/dbnp/studycapturing

Files:

• TemplateEntity.groovy (modified) (8 diffs)
• TemplateFieldType.groovy (modified) (3 diffs)

trunk/grails-app/domain/dbnp/studycapturing/TemplateEntity.groovy

@@ -21 +21 @@
         Map templateDoubleFields = [:]
         Map templateDateFields = [:]
+        Map templateRelTimeFields = [:] // Contains relative times in seconds
         Map templateTermFields = [:]
 
@@ -32 +33 @@
                 templateDateFields: Date,
                 templateTermFields: Term,
+                templateRelTimeFields: long,
                 systemFields: TemplateField
         ]
@@ -200 +202 @@
                         return (!error)
                 })
+                templateRelTimeFields(validator: { fields, obj, errors ->
+                        def error = false
+                        fields.each { key, value ->
+                                if ( value && value.class != long ) {
+                                        try {
+                                                fields[key] = (value as long)
+                                        } catch (Exception e) {
+                                                error = true
+                                                errors.rejectValue(
+                                                        'templateRelTimeFields',
+                                                        'templateEntity.typeMismatch.reltime',
+                                                        [key, value.class] as Object[],
+                                                        'Property {0} must be of type long and is currently of type {1}'
+                                                )
+                                        }
+                                }
+                        }
+                        return (!error)
+                })
                 templateTermFields(validator: { fields, obj, errors ->
                         def error = false
@@ -228 +249 @@
          * @throws NoSuchFieldException
          */
-        private Map getStore(TemplateFieldType fieldType) {
+        public Map getStore(TemplateFieldType fieldType) {
                 switch(fieldType) {
                         case TemplateFieldType.STRING:
@@ -240 +261 @@
                         case TemplateFieldType.DATE:
                                 return templateDateFields
+                        case TemplateFieldType.RELTIME:
+                                return templateRelTimeFields
                         case TemplateFieldType.FLOAT:
                                 return templateFloatFields
@@ -353 +376 @@
                 }
 
+                // Magic setter for relative times: handle string values for relTime fields
+                //
+                // The relative time may be set as a string, using the following format
+                //
+                //    #w #d #h #m #s
+                //
+                // Where w = weeks, d = days, h = hours, m = minutes, s = seconds
+                //
+                // The spaces between the values are optional. Every timespan
+                // (w, d, h, m, s) must appear at most once. You can also omit
+                // timespans if needed or use a different order.
+                // Other characters are disregarded, allthough results may not
+                // always be as expected.
+                //  
+                // If an incorrect format is used, which can't be parsed
+                // an IllegalArgumentException is thrown.
+                //
+                // An empty span is treated as zero seconds.
+                //
+                // Examples:
+                // ---------
+                //    5d 3h 20m     // 5 days, 3 hours and 20 minutes
+                //    6h 2d         // 2 days, 6 hours
+                //    10m 200s      // 13 minutes, 20 seconds (200s == 3m + 20s)
+                //    5w4h15m       // 5 weeks, 4 hours, 15 minutes
+                //
+                //    16x14w10d     // Incorrect. 16x is disregarded, so the
+                //                  // result is 15 weeks, 3 days
+                //    13days        // Incorrect: days should be d, but this is
+                //                  // parsed as 13d, 0 seconds
+                //
+                if (field.type == TemplateFieldType.RELTIME && value.class == String) {
+                        // A string was given, attempt to transform it into a timespan
+
+                        // An empty string should be parsed as 0
+                        if( value.trim() == "" ) {
+                            value = 0;
+                        } else {
+                            // Find all parts that contain numbers with
+                            // a character w, d, h, m or s after it
+                            def periodMatch = value =~ /([0-9]+)([wdhms])/
+                            if (periodMatch.size() > 0 ) {
+                                    def seconds = 0L;
+
+                                    // Now check if every part contains data for
+                                    // the time interval
+                                    periodMatch.each {
+                                        def partValue
+
+                                        println it
+
+                                        if( it[1].isLong() ) {
+                                            partValue = Long.parseLong( it[1] );
+                                        } else {
+                                            partValue = 0;
+                                        }
+
+                                        switch( it[ 2 ] ) {
+                                            case 'w':
+                                                seconds += 7L * 24 * 60 * 60 * partValue;
+                                                break;
+                                            case 'd':
+                                                seconds += 24L * 60 * 60 * partValue;
+                                                break;
+                                            case 'h':
+                                                seconds += 60L * 60 * partValue;
+                                                break;
+                                            case 'm':
+                                                seconds += 60L * partValue;
+                                                break;
+                                            case 's':
+                                                seconds += partValue;
+                                                break;
+                                            default:
+                                                adf.error.warn( 'Parsing relative time: ' + it[0] + it[1] + ' is not understood and disregarded' );
+                                                break;
+                                        }
+                                    }
+
+                                    // Continue with the computed value
+                                    value = seconds;
+                            } else {
+                                throw new IllegalArgumentException( "String " + value + " cannot be parsed as a relative time. Use format #w #d #h #m #s." );
+                            }
+                        }
+                }
+
                 // Magic setter for ontology terms: handle string values
                 if (field.type == TemplateFieldType.ONTOLOGYTERM && value && value.class == String) {
@@ -384 +494 @@
                         // If that is ever changed, the results are pretty much unpredictable (random Java object pointers?)!
                         def store = getStore(field.type)
-                        if (!value && store[fieldName]) {
-                                println ".unsetting [" + ((super) ? super.class : '??') + "] template field: [" + fieldName + "]"
-
-                                // remove the item from the Map (if present)
-                                store.remove(fieldName)
-                        } else if (value) {
-                                println ".setting [" + ((super) ? super.class : '??') + "] template field: [" + fieldName + "] ([" + value.toString() + "] of type [" + value.class + "])"
-
-                                // set value
-                                store[fieldName] = value
-                        }
+
+                        // If some value is entered (or 0), then save the value
+                        // otherwise, it should not be present in the store, so
+                        // it is unset if it is.
+                        if ( value || value == 0 ) {
+                            println ".setting [" + ((super) ? super.class : '??') + "] template field: [" + fieldName + "] ([" + value.toString() + "] of type [" + value.class + "])"
+
+                            // set value
+                            store[fieldName] = value
+                        } else if ( store[fieldName] ) {
+                            println ".unsetting [" + ((super) ? super.class : '??') + "] template field: [" + fieldName + "]"
+
+                            // remove the item from the Map (if present)
+                            store.remove(fieldName)
+                        }
                 }
 
@@ -420 +534 @@
         /**
          * Return all fields defined in the underlying template and the built-in
-     * domain fields of this entity
+         * domain fields of this entity
          */
         def List<TemplateField> giveFields() {

trunk/grails-app/domain/dbnp/studycapturing/TemplateFieldType.groovy

@@ -17 +17 @@
         ONTOLOGYTERM('Ontology Reference'),
         DATE('Date'),
-    RELDATE('Relative date') // relative date, e.g. days since start of study
+        RELTIME('Relative time') // relative date, e.g. days since start of study
 
         String name
@@ -26 +26 @@
 
         static list() {
-                [STRING, TEXT, INTEGER, FLOAT, DOUBLE, STRINGLIST, ONTOLOGYTERM, DATE, RELDATE]
+                [STRING, TEXT, INTEGER, FLOAT, DOUBLE, STRINGLIST, ONTOLOGYTERM, DATE, RELTIME]
         }
 
@@ -45 +45 @@
                         case DATE:
                                 return null
-            case RELDATE:
-                return null
+                        case RELTIME:
+                                return null
                         default:
                                 throw new NoSuchFieldException("Field type ${fieldType} not recognized")