Changeset 1264


Ignore:
Timestamp:
Dec 14, 2010, 5:44:23 PM (6 years ago)
Author:
work@…
Message:

resolves issue #233, validation of an object which inherits from TemplateEntity? does not result in an error when required templateFields are missing.

Location:
trunk/grails-app
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/grails-app/domain/dbnp/studycapturing/Template.groovy

    r1257 r1264  
    201201
    202202        /**
     203         * get all required fields
     204         * @param Class fieldType
     205         * @return Set < TemplateField >
     206         */
     207        def getRequiredFieldsByType(TemplateFieldType fieldType) {
     208                def result = fields.findAll {
     209                        (it.required == true && it.type == fieldType)
     210                }
     211                return result;
     212        }
     213
     214        /**
    203215         * Checks whether this template is used by any object
    204216         *
  • trunk/grails-app/domain/dbnp/studycapturing/TemplateEntity.groovy

    r1257 r1264  
    1818 */
    1919abstract class TemplateEntity extends Identity {
    20         /** The actual template of this TemplateEntity instance */
     20        // The actual template of this TemplateEntity instance
    2121        Template template
    2222
     
    5555        ]
    5656
     57        // remember required fields when
     58        // so we can validate is the required
     59        // template fields are set
     60        boolean requiredFieldsSet       = false
     61        Set requiredFields                      = []
     62
     63        /**
     64         * Get the required fields for the defined template, currently
     65         * this method is called in custom validators below but it's
     66         * best to call it in a template setter method. But as that
     67         * involves a lot of refactoring this implementation will do
     68         * fine for now.
     69         *
     70         * Another possible issue might be that if the template is
     71         * updated after the required fields are cached in the object.
     72         *
     73         * @return Set  requiredFields
     74         */
     75        final Set getRequiredFields() {
     76                if (template) {
     77                        // template is set, check if required fields
     78                        // have already been fetched
     79                        if (!requiredFieldsSet) {
     80                                // no, fetch required fields
     81                                requiredFields          = template.getRequiredFields()
     82                                requiredFieldsSet       = true
     83                        }
     84
     85                        // return the required fields
     86                        return requiredFields
     87                } else {
     88                        // template is not yet set, return
     89                        // an empty set
     90                        return []
     91                }
     92        }
     93
     94        // overload transients from Identity
     95        // and append requiredFields vars
     96        static transients                       = [ "identifier", "iterator", "maximumIdentity", "requiredFieldsSet", "requiredFields" ]
     97
     98        // define the mapping
    5799        static mapping = {
    58100                // Specify that each TemplateEntity-subclassing entity should have its own tables to store TemplateField values.
     
    130172                        }
    131173
     174                        // validating the required template fields. Note that the
     175                        // getRequiredFields() are cached in this object, so any
     176                        // template changes after caching may not be validated
     177                        // properly.
     178                        obj.getRequiredFields().findAll { it.type == TemplateFieldType.STRING }.each { field ->
     179                                if (! fields.find { key, value -> key == field.name } ) {
     180                                        // required field is missing
     181                                        error = true
     182                                        errors.rejectValue(
     183                                                'templateStringFields',
     184                                                'templateEntity.required',
     185                                                [field.name] as Object[],
     186                                                'Property {0} is required but it missing'
     187                                        )
     188                                }
     189                        }
     190
    132191                        // got an error, or not?
    133192                        return (!error)
     
    150209                                }
    151210                        }
     211
     212                        // validating required fields
     213                        obj.getRequiredFields().findAll { it.type == TemplateFieldType.TEXT }.each { field ->
     214                                if (! fields.find { key, value -> key == field.name } ) {
     215                                        // required field is missing
     216                                        error = true
     217                                        errors.rejectValue(
     218                                                'templateTextFields',
     219                                                'templateEntity.required',
     220                                                [field.name] as Object[],
     221                                                'Property {0} is required but it missing'
     222                                        )
     223                                }
     224                        }
     225
    152226                        return (!error)
    153227                })
     
    169243                                }
    170244                        }
     245
     246                        // validating required fields
     247                        obj.getRequiredFields().findAll { it.type == TemplateFieldType.STRINGLIST }.each { field ->
     248                                if (! fields.find { key, value -> key == field.name } ) {
     249                                        // required field is missing
     250                                        error = true
     251                                        errors.rejectValue(
     252                                                'templateStringFields',
     253                                                'templateEntity.required',
     254                                                [field.name] as Object[],
     255                                                'Property {0} is required but it missing'
     256                                        )
     257                                }
     258                        }
     259
    171260                        return (!error)
    172261                })
     
    193282                                }
    194283                        }
     284
     285                        // validating required fields
     286                        obj.getRequiredFields().findAll { it.type == TemplateFieldType.DOUBLE }.each { field ->
     287                                if (! fields.find { key, value -> key == field.name } ) {
     288                                        // required field is missing
     289                                        error = true
     290                                        errors.rejectValue(
     291                                                'templateDoubleFields',
     292                                                'templateEntity.required',
     293                                                [field.name] as Object[],
     294                                                'Property {0} is required but it missing'
     295                                        )
     296                                }
     297                        }
     298
    195299                        return (!error)
    196300                })
     
    212316                                }
    213317                        }
     318
     319                        // validating required fields
     320                        obj.getRequiredFields().findAll { it.type == TemplateFieldType.DATE }.each { field ->
     321                                if (! fields.find { key, value -> key == field.name } ) {
     322                                        // required field is missing
     323                                        error = true
     324                                        errors.rejectValue(
     325                                                'templateDateFields',
     326                                                'templateEntity.required',
     327                                                [field.name] as Object[],
     328                                                'Property {0} is required but it missing'
     329                                        )
     330                                }
     331                        }
     332
    214333                        return (!error)
    215334                })
     
    239358                                }
    240359                        }
     360
     361                        // validating required fields
     362                        obj.getRequiredFields().findAll { it.type == TemplateFieldType.RELTIME }.each { field ->
     363                                if (! fields.find { key, value -> key == field.name } ) {
     364                                        // required field is missing
     365                                        error = true
     366                                        errors.rejectValue(
     367                                                'templateRelTimeFields',
     368                                                'templateEntity.required',
     369                                                [field.name] as Object[],
     370                                                'Property {0} is required but it missing'
     371                                        )
     372                                }
     373                        }
     374
    241375                        return (!error)
    242376                })
     
    258392                                }
    259393                        }
     394
     395                        // validating required fields
     396                        obj.getRequiredFields().findAll { it.type == TemplateFieldType.ONTOLOGYTERM }.each { field ->
     397                                if (! fields.find { key, value -> key == field.name } ) {
     398                                        // required field is missing
     399                                        error = true
     400                                        errors.rejectValue(
     401                                                'templateTermFields',
     402                                                'templateEntity.required',
     403                                                [field.name] as Object[],
     404                                                'Property {0} is required but it missing'
     405                                        )
     406                                }
     407                        }
     408
    260409                        return (!error)
    261410                })
     
    295444                        }
    296445
     446                        // validating required fields
     447                        obj.getRequiredFields().findAll { it.type == TemplateFieldType.FILE }.each { field ->
     448                                if (! fields.find { key, value -> key == field.name } ) {
     449                                        // required field is missing
     450                                        error = true
     451                                        errors.rejectValue(
     452                                                'templateFileFields',
     453                                                'templateEntity.required',
     454                                                [field.name] as Object[],
     455                                                'Property {0} is required but it missing'
     456                                        )
     457                                }
     458                        }
     459
    297460                        // got an error, or not?
    298461                        return (!error)
     
    307470                                }
    308471                        }
     472
    309473                        return (!error)
    310474                })
     
    326490                                }
    327491                        }
     492
     493                        // validating required fields
     494                        obj.getRequiredFields().findAll { it.type == TemplateFieldType.TEMPLATE }.each { field ->
     495                                if (! fields.find { key, value -> key == field.name } ) {
     496                                        // required field is missing
     497                                        error = true
     498                                        errors.rejectValue(
     499                                                'templateTemplateFields',
     500                                                'templateEntity.required',
     501                                                [field.name] as Object[],
     502                                                'Property {0} is required but it missing'
     503                                        )
     504                                }
     505                        }
     506
    328507                        return (!error)
    329508                })
     
    345524                                }
    346525                        }
     526
     527                        // validating required fields
     528                        obj.getRequiredFields().findAll { it.type == TemplateFieldType.MODULE }.each { field ->
     529                                if (! fields.find { key, value -> key == field.name } ) {
     530                                        // required field is missing
     531                                        error = true
     532                                        errors.rejectValue(
     533                                                'templateModuleFields',
     534                                                'templateEntity.required',
     535                                                [field.name] as Object[],
     536                                                'Property {0} is required but it missing'
     537                                        )
     538                                }
     539                        }
     540
    347541                        return (!error)
    348542                })
     
    369563                                }
    370564                        }
     565
     566                        // validating required fields
     567                        obj.getRequiredFields().findAll { it.type == TemplateFieldType.LONG }.each { field ->
     568                                if (! fields.find { key, value -> key == field.name } ) {
     569                                        // required field is missing
     570                                        error = true
     571                                        errors.rejectValue(
     572                                                'templateLongFields',
     573                                                'templateEntity.required',
     574                                                [field.name] as Object[],
     575                                                'Property {0} is required but it missing'
     576                                        )
     577                                }
     578                        }
     579
    371580                        return (!error)
    372581                })
  • trunk/grails-app/i18n/messages.properties

    r1260 r1264  
    6161
    6262# TemplateEntity errors
     63templateEntity.required={0} is required and may not be left blank
    6364templateEntity.typeMismatch.long={0} has to be an absolute number (without comma's)
    6465templateEntity.typeMismatch.double={0} must be a number
  • trunk/grails-app/i18n/messages_nl.properties

    r1260 r1264  
    6262
    6363# Template entity meesages
     64templateEntity.required={0} is verplicht en mag niet leeg zijn
    6465templateEntity.typeMismatch.long={0} moet een absoluut getal zijn (zonder komma's)
    6566templateEntity.typeMismatch.double={0} moet een getal zijn
Note: See TracChangeset for help on using the changeset viewer.