Changeset 212

Show
Ignore:
Timestamp:
25-02-10 15:06:16 (4 years ago)
Author:
keesvb
Message:

refactored template entity code into TemplateEntity?, added more template field types, updated BootStrap? with some more details on PPSH, changed code in study overview to get template field contents in a nicer way

Location:
trunk/grails-app
Files:
1 added
8 modified

Legend:

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

    r211 r212  
    55import dbnp.data.Ontology 
    66import dbnp.data.Term 
     7import java.text.SimpleDateFormat 
    78 
    89/** 
     
    7273                        ).with { if (!validate()) { errors.each { println it} } else save()} 
    7374 
    74  
    75                         // added by Jahn for testing the event views 
    76                         def treatmentProtocol2 = new Protocol( 
    77                                 name: 'MADMAX Experimental Protocol 2', 
     75                        def fastingProtocol = new Protocol( 
     76                                name: 'Fasting', 
    7877                                reference: treatmentTerm 
    7978                        ).with { if (!validate()) { errors.each { println it} } else save()} 
     
    9392                        .save() 
    9493 
    95  
    96                         // added by Jahn for testing the event views 
    97                         treatmentProtocol2 
    98                         .addToParameters(new ProtocolParameter( 
    99                                 name: 'Diet', 
    100                                 type: ProtocolParameterType.STRINGLIST, 
    101                                 listEntries: ['99% fat (crude oil)','1% fat (palm oil)'])) 
    102                         .addToParameters(new ProtocolParameter( 
    103                                 name: 'BackgroundDiet', 
     94                        fastingProtocol 
     95                        .addToParameters(new ProtocolParameter( 
     96                                name: 'Fasting period', 
    10497                                type: ProtocolParameterType.STRING)) 
    10598                        .save() 
     
    143136                                listEntries: ['Male','Female']) 
    144137                        .with { if (!validate()) { errors.each { println it} } else save()} 
     138                        def ageField = new TemplateSubjectField( 
     139                                name: 'Age',type: TemplateFieldType.INTEGER) 
     140                        .with { if (!validate()) { errors.each { println it} } else save()} 
    145141 
    146142                        // Mouse template 
     
    151147                                listEntries: ['C57/Bl6j','wild type'])) 
    152148                        .addToSubjectFields(genderField) 
    153                         .addToSubjectFields(new TemplateSubjectField( 
    154                                 name: 'Age',type: TemplateFieldType.INTEGER)) 
     149                        .addToSubjectFields(ageField) 
    155150                        .addToSubjectFields(new TemplateSubjectField( 
    156151                                name: 'Cage',type: TemplateFieldType.INTEGER)) 
    157152                        .addToSubjectFields(new TemplateSubjectField( 
    158                                 name: 'Some float', type: TemplateFieldType.FLOAT)) 
     153                                name: 'Some double', type: TemplateFieldType.DOUBLE)) 
    159154                        .addToSubjectFields(new TemplateSubjectField( 
    160155                                name: 'Some ontology', type: TemplateFieldType.ONTOLOGYTERM)) 
     
    165160                                name: 'Human') 
    166161                        .addToSubjectFields(genderField) 
     162                        .addToSubjectFields(ageField) 
     163                        .addToSubjectFields(new TemplateSubjectField( 
     164                                name: 'DOB',type: TemplateFieldType.DATE)) 
     165                        .addToSubjectFields(new TemplateSubjectField( 
     166                                name: 'Height',type: TemplateFieldType.DOUBLE)) 
     167                        .addToSubjectFields(new TemplateSubjectField( 
     168                                name: 'Weight',type: TemplateFieldType.DOUBLE)) 
     169                        .addToSubjectFields(new TemplateSubjectField( 
     170                                name: 'BMI',type: TemplateFieldType.DOUBLE)) 
    167171                        .with { if (!validate()) { errors.each { println it} } else save()} 
    168172 
     
    191195 
    192196 
    193                         def eventTreatment2 = new EventDescription( 
    194                                 name: 'Diet treatment', 
    195                                 description: 'Treatment Protocol NuGO PPSH', 
    196                                 protocol: treatmentProtocol2, 
     197                        def fastingTreatment = new EventDescription( 
     198                                name: 'Fasting treatment', 
     199                                description: 'Fasting Protocol NuGO PPSH', 
     200                                protocol: fastingProtocol, 
    197201                                isSamplingEvent: false 
    198202                        ).with { if (!validate()) { errors.each { println it} } else save()} 
     
    244248                                title:"NuGO PPS human study", 
    245249                                code:"PPSH", 
    246                                 researchQuestion:"etc.", 
     250                                researchQuestion:"How much are fasting plasma and urine metabolite levels affected by prolonged fasting ?", 
    247251                                description:"Human study", 
    248252                                ecCode:"unknown", 
    249                                 startDate: Date.parse('yyyy-MM-dd','2008-01-11'), 
     253                                startDate: Date.parse('yyyy-MM-dd','2009-01-01'), 
    250254                                template: humanTemplate 
    251255                        ).with { if (!validate()) { errors.each { println it} } else save()} 
    252256 
    253257                        def y=1 
    254                         5.times { 
     258                        11.times { 
    255259                                def currentSubject = new Subject( 
    256                                         name: "A" + y++, 
     260                                        name: "" + y++, 
    257261                                        species: humanTerm, 
    258262                                        template: humanTemplate, 
    259                                         templateStringFields: ["Gender" : "Male"], 
     263                                        templateStringFields: [ 
     264                                                "Gender" : (boolean)(x/2) ? "Male" : "Female" 
     265                                                ], 
     266                                        templateDateFields: [ 
     267                                                "DOB" : new java.text.SimpleDateFormat("dd-mm-yy").parse("01-02-19"+(10+(int)(Math.random()*80))) 
     268                                        ], 
     269                                        templateIntegerFields: [ 
     270                                                "Age" : 30 
     271                                        ], 
     272                                        templateDoubleFields: [ 
     273                                                "Height" : Math.random()*2F, 
     274                                                "Weight" : Math.random()*150F, 
     275                                                "BMI" : 20 + Math.random()*10F 
     276                                        ] 
    260277                                ).with { if (!validate()) { errors.each { println it} } else save()} 
    261278 
     
    265282                                        startTime: Date.parse('yyyy-MM-dd','2008-01-14'), 
    266283                                        endTime: Date.parse('yyyy-MM-dd','2008-01-14'), 
    267                                         eventDescription: eventTreatment2, 
    268                                         parameterStringValues: ['Diet':'99% fat (crude oil)','BackgroundDiet':'Mediterranean diet']) 
     284                                        eventDescription: fastingTreatment, 
     285                                        parameterStringValues: ['Fasting period':'8h']) 
    269286                                ) 
    270287                                .addToSamplingEvents(new SamplingEvent( 
  • trunk/grails-app/domain/dbnp/studycapturing/Study.groovy

    r190 r212  
    99 * $Date$ 
    1010 */ 
    11 class Study implements Serializable { 
     11class Study extends TemplateEntity implements Serializable { 
    1212        static searchable = true 
    1313        nimble.User owner 
     
    2222        Template template 
    2323 
    24         static hasMany = [      editors: nimble.User, 
    25                         readers: nimble.User, 
    26                         subjects: Subject, 
    27                         groups: SubjectGroup, 
    28                         events: Event, 
    29                         samplingEvents: SamplingEvent, 
    30                         assays: Assay, 
    31             persons: StudyPerson, 
    32             publications: Publication 
     24        static hasMany = [ 
     25                editors: nimble.User, 
     26                readers: nimble.User, 
     27                subjects: Subject, 
     28                groups: SubjectGroup, 
     29                events: Event, 
     30                samplingEvents: SamplingEvent, 
     31                assays: Assay, 
     32                persons: StudyPerson, 
     33                publications: Publication 
    3334        ] 
    3435 
  • trunk/grails-app/domain/dbnp/studycapturing/Subject.groovy

    r190 r212  
    1111 * $Date$ 
    1212 */ 
    13 class Subject implements Serializable { 
     13class Subject extends TemplateEntity implements Serializable { 
    1414        static searchable = true 
    1515        Template template 
    1616        String name 
    1717        Term species 
    18         Map templateStringFields 
    19         Map templateIntegerFields 
    20         Map templateFloatFields 
    21         Map templateTermFields 
    22  
    23         static hasMany = [ 
    24                 templateStringFields: String, // stores both STRING and STRINGLIST items (latter should be checked against the list) 
    25                 templateIntegerFields: int, 
    26                 templateFloatFields: float, 
    27                 templateTermFields: Term 
    28         ] 
    29  
    30         static constraints = { 
    31         } 
    32  
    33         /** 
    34          * Find a template field by its name and return its value for this subject 
    35          * @param fieldName The name of the template subject field 
    36          * @return the value of the field (class depends on the field type) 
    37          * @throws NoSuchFieldException If the field is not found or the field type is not supported 
    38          */ 
    39         def getFieldValue(String fieldName) { 
    40                 TemplateFieldType fieldType = template.getSubjectFieldType(fieldName) 
    41                 if (!fieldType) throw new NoSuchFieldException("Field name ${fieldName} not recognized") 
    42                 switch(fieldType) { 
    43                         case [TemplateFieldType.STRING, TemplateFieldType.STRINGLIST]: 
    44                                 return templateStringFields[fieldName] 
    45                         case TemplateFieldType.INTEGER: 
    46                                 return templateIntegerFields[fieldName] 
    47                         case TemplateFieldType.FLOAT: 
    48                                 return templateFloatFields[fieldName] 
    49                         case TemplateFieldType.ONTOLOGYTERM: 
    50                                 return templateTermFields[fieldName] 
    51                         default: 
    52                                 throw new NoSuchFieldException("Field type ${fieldType} not recognized") 
    53                 } 
    54         } 
    55  
    56         def setFieldValue(String fieldName, value) { 
    57                 this.properties.each { println it} 
    58                 if (this.properties.containsKey(fieldName)) { 
    59                         this[fieldName] = value 
    60                 } 
    61                 else if (templateStringFields.containsKey(fieldName) && value.class == String) { 
    62                         this.templateStringFields[fieldName] = value 
    63                 } 
    64                 else { 
    65                         println "Field ${fieldName} not found" 
    66                 } 
    67         } 
    6818} 
  • trunk/grails-app/domain/dbnp/studycapturing/TemplateFieldType.groovy

    r190 r212  
    1111        STRING('String'), 
    1212        INTEGER('Integer number'), 
    13         FLOAT('Decimal number'), 
     13        FLOAT('Floating-point number'), 
     14        DOUBLE('Double precision floating-point number'), 
    1415        STRINGLIST('List of items'), 
    15         ONTOLOGYTERM('Ontology Reference') 
     16        ONTOLOGYTERM('Ontology Reference'), 
     17        DATE('Date') 
    1618 
    1719        String name 
     
    2224 
    2325        static list() { 
    24                 [STRING, INTEGER, FLOAT, STRINGLIST, ONTOLOGYTERM] 
     26                [STRING, INTEGER, FLOAT, DOUBLE, STRINGLIST, ONTOLOGYTERM, DATE] 
    2527        } 
    2628 
  • trunk/grails-app/domain/dbnp/studycapturing/Template.groovy

    r190 r212  
    44 * The Template class describes a study template, which is basically an extension of the study capture entities 
    55 * in terms of extra fields (described by classes that extend the TemplateField class). 
    6  * At this moment, only extension of the subject entity is implemented. 
     6 * At this moment, only extension of the study and subject entities is implemented. 
    77 * 
    88 * Revision information: 
  • trunk/grails-app/domain/dbnp/studycapturing/TemplateStudyField.groovy

    r190 r212  
    1212class TemplateStudyField extends TemplateField { 
    1313        static constraints = { 
     14                name(unique: true) 
    1415        } 
    1516 
  • trunk/grails-app/views/study/list_extended.gsp

    r210 r212  
    113113                <g:each in="${stud.template.subjectFields}" var="g"> 
    114114               <td> 
    115               <% if (g.type==dbnp.studycapturing.TemplateFieldType.INTEGER){ %> 
    116                   <% print s.templateIntegerFields.get(g.toString())  %> 
    117               <% } %> 
    118                <% if (g.type==dbnp.studycapturing.TemplateFieldType.STRINGLIST){ %> 
    119                 <% print s.templateStringFields.get(g.toString())  %> 
    120               <% } %> 
    121  
     115                  <% print s.getFieldValue(g.toString())  %> 
    122116            </td> 
    123117          </g:each> 
  • trunk/grails-app/views/study/show.gsp

    r211 r212  
    138138                <g:each in="${studyInstance.template.subjectFields}" var="g"> 
    139139               <td> 
    140               <% if (g.type==dbnp.studycapturing.TemplateFieldType.INTEGER){ %> 
    141                   <% print s.templateIntegerFields.get(g.toString())  %> 
    142               <% } %> 
    143                <% if (g.type==dbnp.studycapturing.TemplateFieldType.STRINGLIST){ %> 
    144                 <% print s.templateStringFields.get(g.toString())  %> 
    145               <% } %> 
    146              <% if (g.type==dbnp.studycapturing.TemplateFieldType.FLOAT){ %> 
    147                 <% print s.templateFloatFields.get(g.toString())  %> 
    148               <% } %> 
    149  
     140                  <% print s.getFieldValue(g.toString())  %> 
    150141            </td> 
    151142          </g:each>