Changeset 332

Timestamp:

Apr 8, 2010, 6:02:16 PM (13 years ago)

Author:

duh

Message:

• introduced template fields validation
• added i18n messaging for validation errors
• added template field validation support to subject fields in wizard
• TODO: an unsetTemplateField(...) method should be added to TemplateEntity? and used in the wizard. As setting an empty value (=empty string) should result in the particular value be unset in the TemplateEntity? instance... This issue results now in not being able to unset previously set template fields.

Location:

trunk/grails-app

Files:

• controllers/dbnp/studycapturing/WizardController.groovy (modified) (3 diffs)
• domain/dbnp/studycapturing/TemplateEntity.groovy (modified) (4 diffs)
• i18n/messages.properties (modified) (1 diff)
• views/wizard/common/_error.gsp (modified) (1 diff)

trunk/grails-app/controllers/dbnp/studycapturing/WizardController.groovy

@@ -590 +590 @@
                 // walk through template fields
                 if (params.template) {
-                        params.template.fields.each() {field ->
+                        params.template.fields.each() { field ->
                                 def value = params.get(field.escapedName())
 
@@ -722 +722 @@
                                 if (!flow.subjects[ subjectId ].validate()) {
                                         errors = true
-                                        this.appendErrors(flow.subjects[ subjectId ], flash.errors)
+                                        this.appendErrors(flow.subjects[ subjectId ], flash.errors, 'subject_' + subjectId + '_')
                                 }
                         }
@@ -755 +755 @@
         def getHumanReadableErrors(object) {
                 def errors = [:]
-
                 object.errors.getAllErrors().each() {
                         errors[it.getArguments()[0]] = it.getDefaultMessage()

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

@@ -2 +2 @@
 
 import dbnp.data.Term
+import org.springframework.validation.FieldError
 
 /**
@@ -12 +13 @@
  */
 abstract class TemplateEntity implements Serializable {
-
         Template template
-
         Map templateStringFields = [:]
         Map templateTextFields = [:]
@@ -35 +34 @@
         ]
 
+        static mapping = {
+                tablePerHierarchy false
+
+                templateTextFields type: 'text'
+        }       
+
+        /**
+         * Contraints
+         *
+         * All template fields have their own custom validator. Note that there
+         * currently is a lot of code repitition. Ideally we don't want this, but
+         * unfortunately due to scope issues we cannot re-use the code. So make sure
+         * to replicate any changes to all pieces of logic!
+         */
         static constraints = {
                 template(nullable: true, blank: true)
-
-        }
-
-        static mapping = {
-                tablePerHierarchy false
-
-                templateTextFields type: 'text'
+                templateStringFields(validator: { fields, obj, errors ->
+                        def error = false
+
+                        // iterate through fields
+                        fields.each { key, value ->
+                                // check if value is of proper type
+                                if (value.class != String) {
+                                        // it's not, try to cast it to the proper type
+                                        try {
+                                                fields[key] = (value as String)
+                                        } catch (Exception e) {
+                                                // could not typecast properly, value is of inproper type
+                                                error = true
+                                                errors.rejectValue(
+                                                        'templateStringFields',
+                                                        'templateEntity.typeMismatch.string',
+                                                        [key, value.class] as Object[],
+                                                        'Property {0} must be of type String and is currently of type {1}'
+                                                )
+                                        }
+                                }
+                        }
+                        return (!error)
+                })
+                templateTextFields(validator: { fields, obj, errors ->
+                        def error = false
+                        fields.each { key, value ->
+                                if (value.class != String) {
+                                        try {
+                                                fields[key] = (value as String)
+                                        } catch (Exception e) {
+                                                error = true
+                                                errors.rejectValue(
+                                                        'templateTextFields',
+                                                        'templateEntity.typeMismatch.string',
+                                                        [key, value.class] as Object[],
+                                                        'Property {0} must be of type String and is currently of type {1}'
+                                                )
+                                        }
+                                }
+                        }
+                        return (!error)
+                })
+                templateStringListFields(validator: { fields, obj, errors ->
+                        def error = false
+                        fields.each { key, value ->
+                                if (value.class != TemplateFieldListItem) {
+                                        try {
+                                                fields[key] = (value as TemplateFieldListItem)
+                                        } catch (Exception e) {
+                                                error = true
+                                                errors.rejectValue(
+                                                        'templateIntegerFields',
+                                                        'templateEntity.typeMismatch.templateFieldListItem',
+                                                        [key, value.class] as Object[],
+                                                        'Property {0} must be of type TemplateFieldListItem and is currently of type {1}'
+                                                )
+                                        }
+                                }
+                        }
+                        return (!error)
+                })
+                templateIntegerFields(validator: { fields, obj, errors ->
+                        def error = false
+                        fields.each { key, value ->
+                                if (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.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 ->
+                                if (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}'
+                                                )
+                                        }
+                                }
+                        }
+                        return (!error)
+                })
+                templateDateFields(validator: { fields, obj, errors ->
+                        def error = false
+                        fields.each { key, value ->
+                                if (value.class != Date) {
+                                        try {
+                                                fields[key] = (value as Date)
+                                        } catch (Exception e) {
+                                                error = true
+                                                errors.rejectValue(
+                                                        'templateDateFields',
+                                                        'templateEntity.typeMismatch.date',
+                                                        [key, value.class] as Object[],
+                                                        'Property {0} must be of type Date and is currently of type {1}'
+                                                )
+                                        }
+                                }
+                        }
+                        return (!error)
+                })
+                templateTermFields(validator: { fields, obj, errors ->
+                        def error = false
+                        fields.each { key, value ->
+                                if (value.class != Term) {
+                                        try {
+                                                fields[key] = (value as Term)
+                                        } catch (Exception e) {
+                                                error = true
+                                                errors.rejectValue(
+                                                        'templateTermFields',
+                                                        'templateEntity.typeMismatch.term',
+                                                        [key, value.class] as Object[],
+                                                        'Property {0} must be of type Term and is currently of type {1}'
+                                                )
+                                        }
+                                }
+                        }
+                        return (!error)
+                })
         }
 
@@ -177 +340 @@
                 if (templates.size() == 0) {
                         throw new NoSuchFieldException("No templates found in collection!")
-                }
-                else if (templates.size() == 1) {
+                } else if (templates.size() == 1) {
                         return templates[0];
-                }
-                else {
+                } else {
                         throw new NoSuchFieldException("Multiple templates found in collection!")
                 }
         }
-
-        def validate() {
-                return super.validate()
-        }
 }

trunk/grails-app/i18n/messages.properties

@@ -54 +54 @@
 typeMismatch.java.math.BigDecimal=Property {0} must be a valid number
 typeMismatch.java.math.BigInteger=Property {0} must be a valid number
+
+// TemplateEntity errors
+templateEntity.typeMismatch.integer=Property {0} must be of type Integer and is currently of type {1}
+templateEntity.typeMismatch.string=Property {0} must be of type String and is currently of type {1}
+templateEntity.typeMismatch.templateFieldListItem=Property {0} must be of type TemplateFieldListItem and is currently of type {1}
+templateEntity.typeMismatch.float=Property {0} must be of type Float and is currently of type {1}
+templateEntity.typeMismatch.double=Property {0} must be of type Double and is currently of type {1}
+templateEntity.typeMismatch.date=Property {0} must be of type Date and is currently of type {1}
+templateEntity.typeMismatch.term=Property {0} must be of type Term and is currently of type {1}

trunk/grails-app/views/wizard/common/_error.gsp

@@ -28 +28 @@
                 // mark error fields
                 <g:each in="${errors}" var="error">
+                var element = $("input:[name='${error.key}'], input:[name='${error.key.toLowerCase().replaceAll("([^a-z0-9])","_")}'], select:[name='${error.key}'], select:[name='${error.key.toLowerCase().replaceAll("([^a-z0-9])","_")}']");
                 <g:if test="${error.value['dynamic']}">
-                $("input:[name='${error.key}'], select:[name='${error.key}']").addClass('error');
+                element.addClass('error');
                 </g:if><g:else>
-                $("input:[name='${error.key}'], select:[name='${error.key}']").parent().parent().addClass('error');
+                element.parent().parent().addClass('error');
                 </g:else>
                 </g:each>