Changeset 212


Ignore:
Timestamp:
Feb 25, 2010, 3:06:16 PM (7 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 edited

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/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/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/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>
Note: See TracChangeset for help on using the changeset viewer.