Ignore:
Timestamp:
May 31, 2010, 10:24:00 AM (10 years ago)
Author:
duh
Message:
  • reformatted some indentations
  • set svn keyword expansion
Location:
trunk/grails-app/domain/dbnp/studycapturing
Files:
3 edited

Legend:

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

    • Property svn:keywords set to Date Rev Author
  • trunk/grails-app/domain/dbnp/studycapturing/TemplateEntity.groovy

    r497 r500  
    2121        Map templateDoubleFields = [:]
    2222        Map templateDateFields = [:]
    23         Map templateRelTimeFields = [:] // Contains relative times in seconds
     23        Map templateRelTimeFields = [:] // Contains relative times in seconds
    2424        Map templateTermFields = [:]
    2525
     
    3333                templateDateFields: Date,
    3434                templateTermFields: Term,
    35                 templateRelTimeFields: long,
     35                templateRelTimeFields: long,
    3636                systemFields: TemplateField
    3737        ]
     
    4141
    4242                templateTextFields type: 'text'
    43         }       
     43        }
    4444
    4545        /**
     
    6666                        fields.each { key, value ->
    6767                                // check if the value is of proper type
    68                                 if ( value && value.class != String ) {
     68                                if (value && value.class != String) {
    6969                                        // it's of some other type
    7070                                        try {
     
    9191                        def error = false
    9292                        fields.each { key, value ->
    93                                 if ( value && value.class != String ) {
     93                                if (value && value.class != String) {
    9494                                        try {
    9595                                                fields[key] = (value as String)
     
    110110                        def error = false
    111111                        fields.each { key, value ->
    112                                 if ( value && value.class != TemplateFieldListItem ) {
     112                                if (value && value.class != TemplateFieldListItem) {
    113113                                        try {
    114114                                                fields[key] = (value as TemplateFieldListItem)
     
    129129                        def error = false
    130130                        fields.each { key, value ->
    131                                 if (value && value.class != Integer ) {
     131                                if (value && value.class != Integer) {
    132132                                        try {
    133133                                                fields[key] = (value as Integer)
     
    148148                        def error = false
    149149                        fields.each { key, value ->
    150                                 if ( value && value.class != Float ) {
     150                                if (value && value.class != Float) {
    151151                                        try {
    152152                                                fields[key] = (value as Float)
     
    167167                        def error = false
    168168                        fields.each { key, value ->
    169                                 if ( value && value.class != Double ) {
     169                                if (value && value.class != Double) {
    170170                                        try {
    171171                                                fields[key] = (value as Double)
     
    186186                        def error = false
    187187                        fields.each { key, value ->
    188                                 if ( value && value.class != Date ) {
     188                                if (value && value.class != Date) {
    189189                                        try {
    190190                                                fields[key] = (value as Date)
     
    205205                        def error = false
    206206                        fields.each { key, value ->
    207                                 if ( value && value.class != long ) {
     207                                if (value && value.class != long) {
    208208                                        try {
    209209                                                fields[key] = (value as long)
     
    224224                        def error = false
    225225                        fields.each { key, value ->
    226                                 if ( value && value.class != Term ) {
     226                                if (value && value.class != Term) {
    227227                                        try {
    228228                                                fields[key] = (value as Term)
     
    250250         */
    251251        public Map getStore(TemplateFieldType fieldType) {
    252                 switch(fieldType) {
     252                switch (fieldType) {
    253253                        case TemplateFieldType.STRING:
    254254                                return templateStringFields
     
    269269                        case TemplateFieldType.ONTOLOGYTERM:
    270270                                return templateTermFields
    271                         default:
     271                        default:
    272272                                throw new NoSuchFieldException("Field type ${fieldType} not recognized")
    273273                }
     
    285285                // (such escaped names are commonly used
    286286                // in the HTTP forms of this application)
    287                 String escapedLowerCaseFieldName = fieldName.toLowerCase().replaceAll("([^a-z0-9])","_")
     287                String escapedLowerCaseFieldName = fieldName.toLowerCase().replaceAll("([^a-z0-9])", "_")
    288288
    289289                // Find the target template field, if not found, throw an error
     
    307307
    308308                if (isDomainField(fieldName)) {
    309                     return this[fieldName]
     309                        return this[fieldName]
    310310                }
    311311                else {
    312                     TemplateField field = getField(this.giveTemplateFields(),fieldName)
    313                     return getStore(field.type)[fieldName]
     312                        TemplateField field = getField(this.giveTemplateFields(), fieldName)
     313                        return getStore(field.type)[fieldName]
    314314                }
    315315
     
    324324                // getField should throw a NoSuchFieldException if the field does not exist
    325325                try {
    326                         TemplateField field = getField(this.giveFields(),fieldName)
     326                        TemplateField field = getField(this.giveFields(), fieldName)
    327327                        // return true if exception is not thrown (but double check if field really is not null)
    328328                        if (field) {
     
    334334                }
    335335                // if exception is thrown, return false
    336                 catch(NoSuchFieldException e) {
     336                catch (NoSuchFieldException e) {
    337337                        return false
    338338                }
     
    346346        def setFieldValue(String fieldName, value) {
    347347                // get the template field
    348                 TemplateField field = getField(this.giveFields(),fieldName)
     348                TemplateField field = getField(this.giveFields(), fieldName)
    349349
    350350                // Convenience setter for template string list fields: find TemplateFieldListItem by name
     
    377377
    378378                // Magic setter for relative times: handle string values for relTime fields
    379                 //
     379                //
    380380                if (field.type == TemplateFieldType.RELTIME && value != null && value.class == String) {
    381                     // A string was given, attempt to transform it into a timespan
    382                     value = RelTime.parseRelTime( value ).getValue();
     381                        // A string was given, attempt to transform it into a timespan
     382                        value = RelTime.parseRelTime(value).getValue();
    383383                }
    384384
     
    408408
    409409                                // remove value. For numbers, this is done by setting
    410                                 // the value to 0, otherwise, setting it to NULL
    411                                 switch( field.type.toString() ) {
    412                                     case ['INTEGER', 'FLOAT', 'DOUBLE', 'RELTIME']:
    413                                         this[field.name] = 0;
    414                                         break;
    415                                     default:
    416                                         this[field.name] = null
    417                                 }
     410                                // the value to 0, otherwise, setting it to NULL
     411                                switch (field.type.toString()) {
     412                                        case ['INTEGER', 'FLOAT', 'DOUBLE', 'RELTIME']:
     413                                                this[field.name] = 0;
     414                                                break;
     415                                        default:
     416                                                this[field.name] = null
     417                                }
    418418                        }
    419419                } else {
     
    422422                        def store = getStore(field.type)
    423423
    424                         // If some value is entered (or 0), then save the value
    425                         // otherwise, it should not be present in the store, so
    426                         // it is unset if it is.
    427                         if ( value || value == 0 ) {
    428                             println ".setting [" + ((super) ? super.class : '??') + "] template field: [" + fieldName + "] ([" + value.toString() + "] of type [" + value.class + "])"
    429 
    430                             // set value
    431                             store[fieldName] = value
    432                         } else if ( store[fieldName] ) {
    433                             println ".unsetting [" + ((super) ? super.class : '??') + "] template field: [" + fieldName + "]"
    434 
    435                             // remove the item from the Map (if present)
    436                             store.remove(fieldName)
    437                         }
     424                        // If some value is entered (or 0), then save the value
     425                        // otherwise, it should not be present in the store, so
     426                        // it is unset if it is.
     427                        if (value || value == 0) {
     428                                println ".setting [" + ((super) ? super.class : '??') + "] template field: [" + fieldName + "] ([" + value.toString() + "] of type [" + value.class + "])"
     429
     430                                // set value
     431                                store[fieldName] = value
     432                        } else if (store[fieldName]) {
     433                                println ".unsetting [" + ((super) ? super.class : '??') + "] template field: [" + fieldName + "]"
     434
     435                                // remove the item from the Map (if present)
     436                                store.remove(fieldName)
     437                        }
    438438                }
    439439
     
    443443        /**
    444444         * Check if a given field is a domain field
    445          * @param TemplateField         field instance
     445         * @param TemplateField field instance
    446446         * @return boolean
    447447         */
    448448        boolean isDomainField(TemplateField field) {
    449             return isDomainField( field.name )
     449                return isDomainField(field.name)
    450450        }
    451451
    452452        /**
    453453         * Check if a given field is a domain field
    454          * @param String        field name
     454         * @param String field name
    455455         * @return boolean
    456456         */
    457         boolean isDomainField(String fieldName) {
    458             return this.giveDomainFields()*.name.contains(fieldName)
    459         }
    460        
     457        boolean isDomainField(String fieldName) {
     458                return this.giveDomainFields()*.name.contains(fieldName)
     459        }
     460
    461461        /**
    462462         * Return all fields defined in the underlying template and the built-in
    463         * domain fields of this entity
     463        * domain fields of this entity
    464464         */
    465465        def List<TemplateField> giveFields() {
     
    477477         * Return all relevant 'built-in' domain fields of the super class
    478478         * @return List with DomainTemplateFields
    479     * @see TemplateField
    480          */
     479        * @see TemplateField
     480         */
    481481        abstract List<TemplateField> giveDomainFields()
    482482
  • trunk/grails-app/domain/dbnp/studycapturing/TemplateFieldType.groovy

    r496 r500  
    1717        ONTOLOGYTERM('Ontology Reference'),
    1818        DATE('Date'),
    19         RELTIME('Relative time') // relative date, e.g. days since start of study
     19        RELTIME('Relative time') // relative date, e.g. days since start of study
    2020
    2121        String name
     
    3030
    3131        def getDefaultValue() {
    32                 switch(this) {
     32                switch (this) {
    3333                        case [STRING, TEXT]:
    3434                                return ""
     
    4545                        case DATE:
    4646                                return null
    47                         case RELTIME:
    48                                 return null
     47                        case RELTIME:
     48                                return null
    4949                        default:
    5050                                throw new NoSuchFieldException("Field type ${fieldType} not recognized")
Note: See TracChangeset for help on using the changeset viewer.