Changeset 392

Show
Ignore:
Timestamp:
04-05-10 17:03:21 (4 years ago)
Author:
keesvb
Message:

switched back from the fancy 'integrate domain fields as system fields directly into the Template object at the time of creation' method to the plain 'implement getFieldValue, setFieldValue and giveFields to work for both domain and template fields'. NB: this might affect Events, since until now startTime and endTime were moved directly into template! Switch any Event.template.fields to Event.giveFields()

Location:
trunk/grails-app
Files:
9 modified

Legend:

Unmodified
Added
Removed
  • trunk/grails-app/conf/BootStrap.groovy

    r389 r392  
    415415 
    416416                        // Event templates 
    417                         println ".adding event templates..." 
    418  
    419                         def startDateField = new TemplateField( 
    420                                 name: 'Start time', type: TemplateFieldType.DATE 
    421                         ).with { if (!validate()) { errors.each { println it} } else save()} 
    422  
    423                         def endDateField = new TemplateField( 
    424                                 name: 'End time', type: TemplateFieldType.DATE 
    425                         ).with { if (!validate()) { errors.each { println it} } else save()} 
    426  
    427                         Event.systemFields = [startDateField,endDateField] 
    428  
    429417                        def dietTreatmentTemplate = new Template( 
    430418                                name: 'Diet treatment', entity: dbnp.studycapturing.Event) 
     
    515503 
    516504                        def evLF = new Event( 
     505                                startTime: Date.parse('yyyy-MM-dd','2008-01-07'), 
     506                                endTime: Date.parse('yyyy-MM-dd','2008-01-14'), 
    517507                                template: dietTreatmentTemplate 
    518508                        ) 
    519509                        .with { if (!validate()) { errors.each { println it} } else save()} 
    520  
    521                         evLF.setStartTime(Date.parse('yyyy-MM-dd','2008-01-07')) 
    522                         evLF.setEndTime(Date.parse('yyyy-MM-dd','2008-01-14')) 
    523  
    524510                        evLF.setFieldValue( 'Diet','10% fat (palm oil)' ) 
    525511                        evLF.save(flush:true) 
    526512 
    527                         println "Saved diet treatment" 
    528                         // TODO: find out why Diet is not set and Compound is 
    529  
    530513                        def evHF = new Event( 
     514                                startTime: Date.parse('yyyy-MM-dd','2008-01-07'), 
     515                                endTime: Date.parse('yyyy-MM-dd','2008-01-14'), 
    531516                                template: dietTreatmentTemplate 
    532517                        ) 
    533                         .setStartTime( Date.parse('yyyy-MM-dd','2008-01-07')) 
    534                         .setEndTime( Date.parse('yyyy-MM-dd','2008-01-14')) 
    535518                        .setFieldValue( 'Diet','45% fat (palm oil)' ) 
    536519                        .with { if (!validate()) { errors.each { println it} } else save()} 
    537520 
    538521                        def evBV = new Event( 
     522                                startTime: Date.parse('yyyy-MM-dd','2008-01-07'), 
     523                                endTime: Date.parse('yyyy-MM-dd','2008-01-14'), 
    539524                                template: boostTreatmentTemplate 
    540525                        ) 
    541                         .setStartTime( Date.parse('yyyy-MM-dd','2008-01-07')) 
    542                         .setEndTime( Date.parse('yyyy-MM-dd','2008-01-14')) 
    543526                        .setFieldValue( 'Compound','Vehicle' ) 
    544527                        .with { if (!validate()) { errors.each { println it} } else save()} 
    545528 
    546529                        def evBL = new Event( 
     530                                startTime: Date.parse('yyyy-MM-dd','2008-01-07'), 
     531                                endTime: Date.parse('yyyy-MM-dd','2008-01-14'), 
    547532                                template: boostTreatmentTemplate 
    548533                        ) 
    549                         .setStartTime( Date.parse('yyyy-MM-dd','2008-01-07')) 
    550                         .setEndTime( Date.parse('yyyy-MM-dd','2008-01-14')) 
    551534                        .setFieldValue( 'Compound','Leptin' ) 
    552535                        .with { if (!validate()) { errors.each { println it} } else save()} 
  • trunk/grails-app/domain/dbnp/studycapturing/Event.groovy

    r389 r392  
    1515class Event extends TemplateEntity implements Serializable { 
    1616 
     17        Date startTime 
     18        Date endTime 
     19         
    1720        static constraints = { 
    18                 startTime(nullable: true) 
    19                 endTime(nullable: true) 
    2021                endTime(validator: {val, obj -> 
    2122           if (val && val.before(obj.startTime)) { 
     
    2526        } 
    2627         
    27         Date getStartTime() { 
    28                 getFieldValue('Start time') 
    29         } 
    3028 
    31         def setStartTime(Date value) { 
    32                 if (value != null) { 
    33                         setFieldValue('Start time',value) 
    34                 } 
    35                 return this 
    36         } 
    37  
    38         Date getEndTime() { 
    39                 getFieldValue('End time') 
    40         } 
    41  
    42         def setEndTime(Date value) { 
    43                 if (value != null) { 
    44                         setFieldValue('End time',value) 
    45                 } 
    46                 return this 
    47         } 
    48  
    49         Map giveDomainFields() { 
    50                 return ['startTime':TemplateFieldType.DATE,'endTime':TemplateFieldType.DATE] 
     29        List<TemplateField> giveDomainFields() { 
     30                [ new TemplateField(  
     31                            name: 'startTime', 
     32                            type: TemplateFieldType.DATE), 
     33                        new TemplateField(  
     34                            name: 'endTime', 
     35                            type: TemplateFieldType.DATE) ]; 
    5136        } 
    5237 
  • trunk/grails-app/domain/dbnp/studycapturing/Sample.groovy

    r389 r392  
    1616        // a member that describes the quantity of the sample? --> should be in the templates 
    1717 
    18         Map giveDomainFields() { 
    19                 return ['name':TemplateFieldType.STRING,'material':TemplateFieldType.ONTOLOGYTERM] 
     18        List<TemplateField> giveDomainFields() { 
     19                [ new TemplateField( 
     20                            name: 'name', 
     21                            type: TemplateFieldType.STRING), 
     22                        new TemplateField( 
     23                            name: 'material', 
     24                            type: TemplateFieldType.ONTOLOGYTERM) ]; 
    2025        } 
    2126 
  • trunk/grails-app/domain/dbnp/studycapturing/Study.groovy

    r389 r392  
    2323        //String ecCode 
    2424 
    25         Map giveDomainFields() { 
    26                 return ['title':TemplateFieldType.STRING,'startDate':TemplateFieldType.DATE] 
     25        List<TemplateField> giveDomainFields() { 
     26                [ new TemplateField(  
     27                            name: 'title', 
     28                            type: TemplateFieldType.STRING), 
     29                        new TemplateField(  
     30                            name: 'startDate',  
     31                            type: TemplateFieldType.DATE) ]; 
    2732        } 
    2833 
  • trunk/grails-app/domain/dbnp/studycapturing/Subject.groovy

    r389 r392  
    1616        Term species 
    1717 
    18         Map giveDomainFields() { 
    19                 return ['name':TemplateFieldType.STRING,'species':TemplateFieldType.ONTOLOGYTERM] 
     18        List<TemplateField> giveDomainFields() { 
     19                [ new TemplateField( 
     20                            name: 'name', 
     21                            type: TemplateFieldType.STRING), 
     22                        new TemplateField( 
     23                            name: 'species', 
     24                            type: TemplateFieldType.ONTOLOGYTERM) ]; 
    2025        } 
    2126} 
  • trunk/grails-app/domain/dbnp/studycapturing/TemplateEntity.groovy

    r390 r392  
    1414abstract class TemplateEntity implements Serializable { 
    1515        Template template 
    16         static List systemFields 
    1716        Map templateStringFields = [:] 
    1817        Map templateTextFields = [:] 
     
    253252 
    254253        /** 
    255          * Find a template field by its name and return its value for this entity 
    256          * @param fieldName The name of the template field 
     254         * Find a domain or template field by its name and return its value for this entity 
     255         * @param fieldName The name of the domain or template field 
    257256         * @return the value of the field (class depends on the field type) 
    258257         * @throws NoSuchFieldException If the field is not found or the field type is not supported 
    259258         */ 
    260259        def getFieldValue(String fieldName) { 
    261                 TemplateFieldType fieldType = template.getFieldType(fieldName) 
    262                 if (!fieldType) throw new NoSuchFieldException("Field name ${fieldName} not recognized") 
    263                 getStore(fieldType)[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] 
     267                } 
    264268        } 
    265269 
     
    375379 
    376380        /** 
     381        * Return all fields defined in the underlying template and the built-in 
     382        * domain fields of this entity 
     383        */ 
     384        def List<TemplateField> giveFields() { 
     385                return this.giveDomainFields() + this.giveTemplateFields(); 
     386        } 
     387 
     388        /** 
    377389        * Return all templated fields defined in the underlying template of this entity 
    378390        */ 
    379         def List<TemplateField> giveFields() { 
     391        def List<TemplateField> giveTemplateFields() { 
    380392                return this.template.fields; 
    381393        } 
    382394 
    383         def List<TemplateField> giveSystemFields() { 
    384                 return systemFields; 
    385         } 
    386          
    387  
    388395        /** 
    389396         * Return all relevant 'built-in' domain fields of the super class 
    390          * @return key-value pairs describing the built-in fields, with the names as keys and type (as TemplateFieldType) as values 
     397         * @return List with DomainTemplateFields 
     398         * @see TemplateField 
    391399         */ 
    392         abstract Map giveDomainFields() 
     400        abstract List<TemplateField> giveDomainFields() 
     401 
    393402        /*def giveDomainFields() { 
    394403                def fieldSet = [:]; 
  • trunk/grails-app/domain/dbnp/studycapturing/Template.groovy

    r384 r392  
    2323                // see http://jira.codehaus.org/browse/GRAILS-6020 
    2424                //      name(unique:['entity']) 
    25         } 
    26  
    27         // As the entity is not known at the time the constructor is called, 
    28         // we add the system fields for a new template object at the time the entity is set 
    29         void setEntity(Class value) { 
    30                 this.entity = value 
    31                 if (value != null) { 
    32                         if (fields == null) { 
    33                                 if (entity.systemFields) { 
    34                                         println "adding default template fields for " + entity.systemFields 
    35                                         entity.systemFields.each { 
    36                                                 this.addToFields(it) 
    37                                         } 
    38                                 } 
    39                         } 
    40                         println "" + value + "this template has now fields " + fields 
    41                 } 
    42  
    4325        } 
    4426 
  • trunk/grails-app/views/study/list_extended.gsp

    r370 r392  
    454454                    <g:each in="${study.persons}" var="studyperson"> 
    455455                      <tr> 
    456                         <td>${studyperson.person.firstName} ${studyperson.person.midInitials} ${studyperson.person.lastName}</td> 
     456                        <td>${studyperson.person.firstName} ${studyperson.person.prefix} ${studyperson.person.lastName}</td> 
    457457                        <td> 
    458458                          ${studyperson.person.affiliations.name.join(', ')} 
  • trunk/grails-app/views/study/show.gsp

    r389 r392  
    273273              <g:each in="${studyInstance.persons}" var="studyperson"> 
    274274                <tr> 
    275                   <td>${studyperson.person.firstName} ${studyperson.person.midInitials} ${studyperson.person.lastName}</td> 
     275                  <td>${studyperson.person.firstName} ${studyperson.person.prefix} ${studyperson.person.lastName}</td> 
    276276                  <td> 
    277277                    ${studyperson.person.affiliations.name.join(', ')}