Ignore:
Timestamp:
May 7, 2010, 2:24:27 PM (9 years ago)
Author:
duh
Message:
  • fixed incomplete implementation of domain fields (getters, setters and constrains logic were all not implemented correctly)
  • refactored wizards pages
  • TODO: constraints on (templated) domain fields are not working anymore, this needs to be implemented properly in TemplateEntity?
File:
1 edited

Legend:

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

    r392 r396  
    258258         */
    259259        def getFieldValue(String fieldName) {
    260                 if (this.properties.containsKey(fieldName)) {
    261                         return this[fieldName]
    262                 }
    263                 else {
    264                         TemplateFieldType fieldType = template.getFieldType(fieldName)
    265                         if (!fieldType) throw new NoSuchFieldException("Field name ${fieldName} not recognized")
    266                         return getStore(fieldType)[fieldName]
     260                // escape the fieldName for easy matching
     261                // (such escaped names are commonly used
     262                // in the HTTP forms of this application)
     263                def escapedLowerCaseFieldName = fieldName.toLowerCase().replaceAll("([^a-z0-9])","_")
     264
     265                // Find the target template field, if not found, throw an error
     266                TemplateField field = this.giveFields().find { it.name.toLowerCase().replaceAll("([^a-z0-9])", "_") == escapedLowerCaseFieldName }
     267
     268                // field found?
     269                if (field == null) {
     270                        // no such field
     271                        throw new NoSuchFieldException("Field ${fieldName} not recognized")
     272                } else {
     273                        return getStore(field.type)[fieldName]
    267274                }
    268275        }
     
    314321                def escapedLowerCaseFieldName = fieldName.toLowerCase().replaceAll("([^a-z0-9])","_")
    315322
    316                 // First, search if there is an entity property with the given name, and if so, set that
    317                 if (this.properties.containsKey(fieldName)) {
    318                         this[fieldName] = value                 
    319                 } else if (template == null) {
    320                         // not the found, then it is a template field, so check if there is a template
    321                         throw new NoSuchFieldException("Field ${fieldName} not found in class properties: template not set")
     323                // Find the target template field, if not found, throw an error
     324                TemplateField field = this.giveFields().find { it.name.toLowerCase().replaceAll("([^a-z0-9])", "_") == escapedLowerCaseFieldName }
     325
     326                // field found?
     327                if (field == null) {
     328                        // no such field
     329                        throw new NoSuchFieldException("Field ${fieldName} not found in class template fields")
    322330                } else {
    323                         // there is a template, check the template fields
    324                         // Find the target template field, if not found, throw an error
    325                         TemplateField field = this.template.fields.find { it.name.toLowerCase().replaceAll("([^a-z0-9])","_") == escapedLowerCaseFieldName }
    326 
    327                         if (field == null) {
    328                                 // no such field
    329                                 throw new NoSuchFieldException("Field ${fieldName} not found in class template fields")
    330                         } else {
    331                                 // Set the value of the found template field
    332                                 // Convenience setter for template string list fields: find TemplateFieldListItem by name
    333                                 if (field.type == TemplateFieldType.STRINGLIST && value && value.class == String) {
    334                                         // Kees insensitive pattern matching ;)
    335                                         def escapedLowerCaseValue = value.toLowerCase().replaceAll("([^a-z0-9])","_")
    336                                         value = field.listEntries.find {
    337                                                 it.name.toLowerCase().replaceAll("([^a-z0-9])","_") == escapedLowerCaseValue
    338                                         }
    339                                 }
    340 
    341                                 // Convenience setter for dates: handle string values for date fields
    342                                 if (field.type == TemplateFieldType.DATE && value.class == String) {
    343                                         // a string was given, attempt to transform it into a date instance
    344                                         // and -for now- assume the dd/mm/yyyy format
    345                                         def dateMatch = value =~ /^([0-9]{1,})([^0-9]{1,})([0-9]{1,})([^0-9]{1,})([0-9]{1,})((([^0-9]{1,})([0-9]{1,2}):([0-9]{1,2})){0,})/
    346                                         if (dateMatch.matches()) {
    347                                                 // create limited 'autosensing' datetime parser
    348                                                 // assume dd mm yyyy  or dd mm yy
    349                                                 def parser = 'd' + dateMatch[0][2] + 'M' + dateMatch[0][4] + (((dateMatch[0][5] as int) > 999) ? 'yyyy' : 'yy')
    350 
    351                                                 // add time as well?
    352                                                 if (dateMatch[0][7] != null) {
    353                                                         parser += dateMatch[0][6] + 'HH:mm'
    354                                                 }
    355 
    356                                                 value = new Date().parse(parser, value)
    357                                         }
    358                                 }
    359 
    360                                 // Set the field value
    361                                 // Caution: this assumes that all template...Field Maps are already initialized (as is done now above as [:])
    362                                 // If that is ever changed, the results are pretty much unpredictable (random Java object pointers?)!
    363                                 def store = getStore(field.type)
    364                                 if (!value && store[ fieldName ]) {
    365                                         println "removing " + ((super) ? super.class : '??') + " template field: " + fieldName
    366 
    367                                         // remove the item from the Map (if present)
    368                                         store.remove( fieldName )
    369                                 } else if (value) {
    370                                         println "setting " + ((super) ? super.class : '??') + " template field: " + fieldName + " ([" + value.toString() + "] of type [" + value.class + "])"
    371 
    372                                         // set value
    373                                         store[ fieldName ] = value
    374                                 }
    375                                 return this
    376                         }
    377                 }
     331                        // Set the value of the found template field
     332                        // Convenience setter for template string list fields: find TemplateFieldListItem by name
     333                        if (field.type == TemplateFieldType.STRINGLIST && value && value.class == String) {
     334                                // Kees insensitive pattern matching ;)
     335                                def escapedLowerCaseValue = value.toLowerCase().replaceAll("([^a-z0-9])", "_")
     336                                value = field.listEntries.find {
     337                                        it.name.toLowerCase().replaceAll("([^a-z0-9])", "_") == escapedLowerCaseValue
     338                                }
     339                        }
     340
     341                        // Convenience setter for dates: handle string values for date fields
     342                        if (field.type == TemplateFieldType.DATE && value && value.class == String) {
     343                                // a string was given, attempt to transform it into a date instance
     344                                // and -for now- assume the dd/mm/yyyy format
     345                                def dateMatch = value =~ /^([0-9]{1,})([^0-9]{1,})([0-9]{1,})([^0-9]{1,})([0-9]{1,})((([^0-9]{1,})([0-9]{1,2}):([0-9]{1,2})){0,})/
     346                                if (dateMatch.matches()) {
     347                                        // create limited 'autosensing' datetime parser
     348                                        // assume dd mm yyyy  or dd mm yy
     349                                        def parser = 'd' + dateMatch[0][2] + 'M' + dateMatch[0][4] + (((dateMatch[0][5] as int) > 999) ? 'yyyy' : 'yy')
     350
     351                                        // add time as well?
     352                                        if (dateMatch[0][7] != null) {
     353                                                parser += dateMatch[0][6] + 'HH:mm'
     354                                        }
     355
     356                                        value = new Date().parse(parser, value)
     357                                }
     358                        }
     359
     360                        // Set the field value
     361                        def store = getStore(field.type)
     362                        if (!value && store[fieldName]) {
     363                                println "removing " + ((super) ? super.class : '??') + " template field: " + fieldName
     364
     365                                // remove the item from the Map (if present)
     366                                store.remove(fieldName)
     367                        } else if (value) {
     368                                println "setting " + ((super) ? super.class : '??') + " template field: " + fieldName + " ([" + value.toString() + "] of type [" + value.class + "])"
     369
     370                                // set value
     371                                store[fieldName] = value
     372                        }
     373                }
     374                return this
    378375        }
    379376
Note: See TracChangeset for help on using the changeset viewer.