Changeset 1153 for trunk/grails-app/domain

Timestamp:

Nov 17, 2010, 11:34:09 AM (10 years ago)

Author:

robert@…

Message:

Removed template field types INTEGER and FLOAT (since LONG and DOUBLE accept more values and keeping both is confusing for the user), see ticket #154.
Also included message in the template editor to show that a string can only contain max 255 characters. (see ticket #193)

Location:

trunk/grails-app/domain/dbnp/studycapturing

Files:

• TemplateEntity.groovy (modified) (9 diffs)
• TemplateFieldType.groovy (modified) (4 diffs)

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

@@ -25 +25 @@
         Map templateTextFields          = [:]
         Map templateStringListFields    = [:]
-        Map templateIntegerFields       = [:]
-        Map templateFloatFields         = [:]
         Map templateDoubleFields        = [:]
         Map templateDateFields          = [:]
@@ -45 +43 @@
                 templateTextFields      : String,
                 templateStringListFields: TemplateFieldListItem,
-                templateIntegerFields   : int,
-                templateFloatFields     : float,
                 templateDoubleFields    : double,
                 templateDateFields      : Date,
@@ -148 +144 @@
                                                 error = true
                                                 errors.rejectValue(
-                                                        'templateIntegerFields',
+                                                        'templateStringFields',
                                                         'templateEntity.typeMismatch.templateFieldListItem',
                                                         [key, value.class] as Object[],
@@ -158 +154 @@
                         return (!error)
                 })
-                templateIntegerFields(validator: { fields, obj, errors ->
-                        def error = false
-                        fields.each { key, value ->
-                                if (value && value.class != Integer) {
-                                        try {
-                                                fields[key] = (value as Integer)
-                                        } catch (Exception e) {
-                                                error = true
-                                                errors.rejectValue(
-                                                        'templateIntegerFields',
-                                                        'templateEntity.typeMismatch.integer',
-                                                        [key, value.class] as Object[],
-                                                        'Property {0} must be of type Integer and is currently of type {1}'
-                                                )
-                                        }
-                                }
-                        }
-                        return (!error)
-                })
-                templateFloatFields(validator: { fields, obj, errors ->
-                        def error = false
-                        fields.each { key, value ->
-                                if (value && value.class != Float) {
-                                        try {
-                                                fields[key] = (value as Float)
-                                        } catch (Exception e) {
-                                                error = true
-                                                errors.rejectValue(
-                                                        'templateFloatFields',
-                                                        'templateEntity.typeMismatch.float',
-                                                        [key, value.class] as Object[],
-                                                        'Property {0} must be of type Float and is currently of type {1}'
-                                                )
-                                        }
-                                }
-                        }
-                        return (!error)
-                })
                 templateDoubleFields(validator: { fields, obj, errors ->
                         def error = false
                         fields.each { key, value ->
+                                // Double field should accept Doubles and Floats
                                 if (value && value.class != Double) {
-                                        try {
-                                                fields[key] = (value as Double)
-                                        } catch (Exception e) {
-                                                error = true
-                                                errors.rejectValue(
-                                                        'templateDoubleFields',
-                                                        'templateEntity.typeMismatch.double',
-                                                        [key, value.class] as Object[],
-                                                        'Property {0} must be of type Double and is currently of type {1}'
-                                                )
+                                        if(value.class == Float) {
+                                                fields[key] = value.toDouble();
+                                        } else {
+                                                try {
+                                                        fields[key] = (value as Double)
+                                                } catch (Exception e) {
+                                                        error = true
+                                                        errors.rejectValue(
+                                                                'templateDoubleFields',
+                                                                'templateEntity.typeMismatch.double',
+                                                                [key, value.class] as Object[],
+                                                                'Property {0} must be of type Double and is currently of type {1}'
+                                                        )
+                                                }
                                         }
                                 }
@@ -370 +333 @@
                         def error = false
                         fields.each { key, value ->
-                                if (value && value.class != Long) {
-                                        try {
-                                                fields[key] = Long.parseLong(value.trim())
-                                        } catch (Exception e) {
-                                                error = true
-                                                errors.rejectValue(
-                                                        'templateLongFields',
-                                                        'templateEntity.typeMismatch.long',
-                                                        [key, value.class] as Object[],
-                                                        'Property {0} must be of type Long and is currently of type {1}'
-                                                )
+                                // Long field should accept Longs and Integers
+                                if (value && value.class != Long ) {
+                                        if( value.class == Integer ) {
+                                                fields[key] = value.toLong();
+                                        } else {
+                                                try {
+                                                        fields[key] = Long.parseLong(value.trim())
+                                                } catch (Exception e) {
+                                                        error = true
+                                                        errors.rejectValue(
+                                                                'templateLongFields',
+                                                                'templateEntity.typeMismatch.long',
+                                                                [key, value.class] as Object[],
+                                                                'Property {0} must be of type Long and is currently of type {1}'
+                                                        )
+                                                }
                                         }
                                 }
@@ -403 +371 @@
                         case TemplateFieldType.STRINGLIST:
                                 return templateStringListFields
-                        case TemplateFieldType.INTEGER:
-                                return templateIntegerFields
                         case TemplateFieldType.DATE:
                                 return templateDateFields
@@ -411 +377 @@
                         case TemplateFieldType.FILE:
                                 return templateFileFields
-                        case TemplateFieldType.FLOAT:
-                                return templateFloatFields
                         case TemplateFieldType.DOUBLE:
                                 return templateDoubleFields
@@ -645 +609 @@
                 // Magic setter for LONG fields
                 if (field.type == TemplateFieldType.LONG && value && value.class == String) {
-                        // TODO, check for invalids?
-                        value = Long.parseLong(value.trim())
+                        // A check for invalidity is done in the validator of these fields. For that
+                        // reason, we just try to parse it here. If it fails, the validator will also
+                        // fail.
+                        try {
+                                value = Long.parseLong(value.trim())
+                        } catch( Exception e ) {}
                 }
 
@@ -661 +629 @@
                                 // the value to 0, otherwise, setting it to NULL
                                 switch (field.type.toString()) {
-                                        case ['INTEGER', 'FLOAT', 'DOUBLE', 'RELTIME', 'LONG']:
+                                        case [ 'DOUBLE', 'RELTIME', 'LONG']:
                                                 this[field.name] = 0;
                                                 break;

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

@@ -10 +10 @@
  */
 public enum TemplateFieldType implements Serializable {
-        STRING('String','Text', ''),                                                                                    // string
-        TEXT('Long string', 'Text', ''),                                                                                // text
-        INTEGER('Integer number', 'Numerical', '1'),                                                    // integer
-        FLOAT('Floating-point number', 'Numerical', '1.0'),                                             // float
-        DOUBLE('Double precision floating-point number', 'Numerical', '1.0'),   // double
+        STRING('String','Text', 'max 255 chars'),                                                                                       // string
+        TEXT('Long string', 'Text', 'unlimited'),                                                                               // text
+        //INTEGER('Integer number', 'Numerical', '1'),                                                  // integer
+        //FLOAT('Floating-point number', 'Numerical', '1.0'),                                           // float
+        DOUBLE('Floating point number', 'Numerical', '1.0'),                                    // double
         STRINGLIST('List of items', 'Text', ''),                                                                // string list
         ONTOLOGYTERM('Ontology Reference', 'Other', ''),                                                // ontology reference
@@ -23 +23 @@
         TEMPLATE('Template', 'Other', ''),                                                                              // template
         MODULE('Module', 'Other', ''),                                                                                  // third party connected module,
-        LONG('Long number', 'Numerical', '100')                                                                 // long
+        LONG('Integer number', 'Numerical', '100')                                                              // long
     // TODO: add a timezone-aware date type to use for study start date
 
@@ -40 +40 @@
 
         static list() {
-                [STRING, TEXT, INTEGER, FLOAT, DOUBLE, STRINGLIST, ONTOLOGYTERM, DATE, RELTIME, FILE, BOOLEAN, TEMPLATE, MODULE, LONG]
+                [STRING, TEXT, DOUBLE, STRINGLIST, ONTOLOGYTERM, DATE, RELTIME, FILE, BOOLEAN, TEMPLATE, MODULE, LONG]
         }
 
@@ -47 +47 @@
                         case [STRING, TEXT]:
                                 return ""
-                        case INTEGER:
-                                return Integer.MIN_VALUE
-                        case FLOAT:
-                                return Float.NaN
                         case DOUBLE:
                                 return Double.MIN_VALUE