Changeset 1264

Show
Ignore:
Timestamp:
14-12-10 17:44:23 (3 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 modified

Legend:

Unmodified
Added
Removed
  • 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/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/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 
  • 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