Changeset 224


Ignore:
Timestamp:
Mar 2, 2010, 6:10:52 PM (7 years ago)
Author:
keesvb
Message:

revised templating system: templates are now per entity rather than per study, moved samples to Study

Location:
trunk/grails-app
Files:
2 deleted
7 edited

Legend:

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

    r212 r224  
    123123
    124124                        // create system user
    125                         /*
    126                         def systemUser = userService.createUser(InstanceGenerator.user(
     125
     126                        /*def systemUser = userService.createUser(InstanceGenerator.user(
    127127                                username: 'system',
    128128                                pass: 'system',
    129129                                passConfirm: 'system',
    130130                                enabled: true
    131                         ))
    132                         */
    133 
    134                         def genderField = new TemplateSubjectField(
     131                        ))*/
     132                       
     133
     134                        def genderField = new TemplateField(
    135135                                name: 'Gender',type: TemplateFieldType.STRINGLIST,
    136136                                listEntries: ['Male','Female'])
    137137                        .with { if (!validate()) { errors.each { println it} } else save()}
    138                         def ageField = new TemplateSubjectField(
     138                        def ageField = new TemplateField(
    139139                                name: 'Age',type: TemplateFieldType.INTEGER)
    140140                        .with { if (!validate()) { errors.each { println it} } else save()}
     
    142142                        // Mouse template
    143143                        def mouseTemplate = new Template(
    144                                 name: 'Mouse'
    145                         ).addToSubjectFields(new TemplateSubjectField(
     144                                name: 'Mouse', entity: dbnp.studycapturing.Subject
     145                        ).addToFields(new TemplateField(
    146146                                name: 'Genotype',type: TemplateFieldType.STRINGLIST,
    147147                                listEntries: ['C57/Bl6j','wild type']))
    148                         .addToSubjectFields(genderField)
    149                         .addToSubjectFields(ageField)
    150                         .addToSubjectFields(new TemplateSubjectField(
     148                        .addToFields(genderField)
     149                        .addToFields(ageField)
     150                        .addToFields(new TemplateField(
    151151                                name: 'Cage',type: TemplateFieldType.INTEGER))
    152                         .addToSubjectFields(new TemplateSubjectField(
     152                        .addToFields(new TemplateField(
    153153                                name: 'Some double', type: TemplateFieldType.DOUBLE))
    154                         .addToSubjectFields(new TemplateSubjectField(
     154                        .addToFields(new TemplateField(
    155155                                name: 'Some ontology', type: TemplateFieldType.ONTOLOGYTERM))
    156156                        .with { if (!validate()) { errors.each { println it} } else save()}
     
    158158                        // Human template
    159159                        def humanTemplate = new Template(
    160                                 name: 'Human')
    161                         .addToSubjectFields(genderField)
    162                         .addToSubjectFields(ageField)
    163                         .addToSubjectFields(new TemplateSubjectField(
     160                                name: 'Human', entity: dbnp.studycapturing.Subject)
     161                        .addToFields(genderField)
     162                        .addToFields(ageField)
     163                        .addToFields(new TemplateField(
    164164                                name: 'DOB',type: TemplateFieldType.DATE))
    165                         .addToSubjectFields(new TemplateSubjectField(
     165                        .addToFields(new TemplateField(
    166166                                name: 'Height',type: TemplateFieldType.DOUBLE))
    167                         .addToSubjectFields(new TemplateSubjectField(
     167                        .addToFields(new TemplateField(
    168168                                name: 'Weight',type: TemplateFieldType.DOUBLE))
    169                         .addToSubjectFields(new TemplateSubjectField(
     169                        .addToFields(new TemplateField(
    170170                                name: 'BMI',type: TemplateFieldType.DOUBLE))
    171171                        .with { if (!validate()) { errors.each { println it} } else save()}
     
    245245                        println 'Adding PPSH study'
    246246
    247             def humanStudy = new Study(
     247                        def humanStudy = new Study(
    248248                                title:"NuGO PPS human study",
    249249                                code:"PPSH",
     
    291291                                        eventDescription: bloodSamplingEvent,
    292292                                        parameterFloatValues: ['Sample volume':4.5F])
    293                                         .addToSamples(new Sample(
    294                                                 name: currentSubject.name + '_B',
    295                                                 material: bloodTerm
    296                                 ))
    297                                 ).with { if (!validate()) { errors.each { println it} } else save()}
     293                                )
     294                                .addToSamples(new Sample(
     295                                        name: currentSubject.name + '_B',
     296                                        material: bloodTerm)
     297                                )
     298                                .with { if (!validate()) { errors.each { println it} } else save()}
    298299                        }
    299300
     
    334335                        ).with { if (!validate()) { errors.each { println it} } else save()}
    335336
    336                         humanStudy.giveSamples()*.each {
     337                        humanStudy.samples*.each {
    337338                                new dbnp.clinicaldata.ClinicalFloatData(
    338339                                        assay: lipidAssayInstance,
     
    365366                        ).with { if (!validate()) { errors.each { println it} } else save()}
    366367
    367                         humanStudy.giveSamples()*.each {
     368                        humanStudy.samples*.each {
    368369                                lipidAssayRef.addToSamples(it)
    369370                        }
     
    372373                        humanStudy.addToAssays(lipidAssayRef);
    373374                        humanStudy.save()
     375
    374376                }
    375377        }
  • trunk/grails-app/domain/dbnp/studycapturing/Sample.groovy

    r190 r224  
    99        static searchable = true
    1010
    11     // TODO: should Sample also carry a reference to its parent study,
    12     // or should this be inferred via the parent SamplingEvent?
     11
    1312
    1413    String name      // should be unique with respect to the parent study (which can be inferred)
    1514    Term material
    16     // don't we need a member that describes the quantity of the sample?
     15    // don't we need a member that describes the quantity of the sample? --> should be in the templates
    1716
    1817    static constraints = {
  • trunk/grails-app/domain/dbnp/studycapturing/Study.groovy

    r212 r224  
    2020        Date lastUpdated
    2121        Date startDate
    22         Template template
    2322
    2423        static hasMany = [
     
    2928                events: Event,
    3029                samplingEvents: SamplingEvent,
     30                samples: Sample,
    3131                assays: Assay,
    3232                persons: StudyPerson,
     
    5050        }
    5151
    52         def giveAllFields() {
    53                 return template.studyFields;
    54         }
    55 
    56         def giveSamples() {
    57                 return samplingEvents*.samples;
    58         }
    5952}
  • trunk/grails-app/domain/dbnp/studycapturing/Subject.groovy

    r212 r224  
    1313class Subject extends TemplateEntity implements Serializable {
    1414        static searchable = true
    15         Template template
    1615        String name
    1716        Term species
  • trunk/grails-app/domain/dbnp/studycapturing/Template.groovy

    r212 r224  
    1212 */
    1313class Template implements Serializable {
     14
    1415        String name
     16        Class entity
    1517        //nimble.User owner
    1618
    17         static hasMany = [studyFields: TemplateStudyField, subjectFields: TemplateSubjectField]
     19        static hasMany = [fields: TemplateField]
    1820
    1921        static constraints = {
    20                 name(unique: true)
     22                name(unique:['entity'])
     23
    2124        }
    2225
     
    3033         * @return The type (static member of TemplateFieldType) of the field, or null of the field does not exist
    3134         */
    32         def TemplateFieldType getSubjectFieldType(String fieldName) {
    33                 def field = subjectFields.find {
     35        def TemplateFieldType getFieldType(String fieldName) {
     36                def field = fields.find {
    3437                        it.name == fieldName   
    3538                }
    3639                field?.type
    3740        }
     41
     42        def getFieldsByType(TemplateFieldType fieldType) {
     43                def result = fields.findAll {
     44                        it.type == fieldType
     45                }
     46                return result;
     47        }
    3848}
  • trunk/grails-app/domain/dbnp/studycapturing/TemplateEntity.groovy

    r212 r224  
    22
    33import dbnp.data.Term
     4import org.codehaus.groovy.runtime.NullObject
    45
    56class TemplateEntity {
    67
     8        Template template
     9
    710        Map templateStringFields
     11        Map templateStringListFields
    812        Map templateIntegerFields
    913        Map templateFloatFields
     
    1317
    1418        static hasMany = [
    15                 templateStringFields: String, // stores both STRING and STRINGLIST items (latter should be checked against the list)
     19                templateStringFields: String,
     20                templateStringListFields: TemplateFieldListItem,
    1621                templateIntegerFields: int,
    1722                templateFloatFields: float,
     
    3136         */
    3237        def getFieldValue(String fieldName) {
    33                 TemplateFieldType fieldType = template.getSubjectFieldType(fieldName)
     38                TemplateFieldType fieldType = template.getFieldType(fieldName)
    3439                if (!fieldType) throw new NoSuchFieldException("Field name ${fieldName} not recognized")
    3540                switch(fieldType) {
    3641                        case [TemplateFieldType.STRING, TemplateFieldType.STRINGLIST]:
    3742                                return templateStringFields[fieldName]
     43                        case [TemplateFieldType.STRINGLIST]:
     44                                return templateStringListFields[fieldName]
    3845                        case TemplateFieldType.INTEGER:
    3946                                return templateIntegerFields[fieldName]
     
    5259
    5360        def setFieldValue(String fieldName, value) {
    54                 this.properties.each { println it}
    5561                if (this.properties.containsKey(fieldName)) {
    5662                        this[fieldName] = value
    5763                }
    58                 else if (templateStringFields.containsKey(fieldName) && value.class == String) {
    59                         this.templateStringFields[fieldName] = value
    60                 }
    61                 else if (templateIntegerFields.containsKey(fieldName) && value.class == Integer) {
    62                         this.templateIntegerFields[fieldName] = value
    63                 }
    64                 else if (templateFloatFields.containsKey(fieldName) && value.class == Float) {
    65                         this.templateFloatFields[fieldName] = value
    66                 }
    67                 else if (templateDoubleFields.containsKey(fieldName) && value.class == Double) {
    68                         this.templateDoubleFields[fieldName] = value
    69                 }
    70                 else if (templateDateFields.containsKey(fieldName) && value.class == Date) {
    71                         this.templateDateFields[fieldName] = value
    72                 }
    73                 else if (templateTermFields.containsKey(fieldName) && value.class == Term) {
    74                         this.templateTermFields[fieldName] = value
     64                else
     65                if (template == null) {
     66                        throw new NoSuchFieldException("Field ${fieldName} not found in class properties")
    7567                }
    7668                else {
    77                         println "Field ${fieldName} not found"
     69                        if (templateStringFields.containsKey(fieldName) && value.class == String) {
     70                                this.templateStringFields[fieldName] = value
     71                        }
     72                        if (templateStringListFields.containsKey(fieldName) && value.class == TemplateFieldListItem) {
     73                                this.templateStringFields[fieldName] = value
     74                        }
     75                        else if (templateIntegerFields.containsKey(fieldName) && value.class == Integer) {
     76                                this.templateIntegerFields[fieldName] = value
     77                        }
     78                        else if (templateFloatFields.containsKey(fieldName) && value.class == Float) {
     79                                this.templateFloatFields[fieldName] = value
     80                        }
     81                        else if (templateDoubleFields.containsKey(fieldName) && value.class == Double) {
     82                                this.templateDoubleFields[fieldName] = value
     83                        }
     84                        else if (templateDateFields.containsKey(fieldName) && value.class == Date) {
     85                                this.templateDateFields[fieldName] = value
     86                        }
     87                        else if (templateTermFields.containsKey(fieldName) && value.class == Term) {
     88                                this.templateTermFields[fieldName] = value
     89                        }
     90                        else {
     91                                throw new NoSuchFieldException("Field ${fieldName} not found in class properties or template fields")
     92                        }
    7893                }
    7994        }
    8095
     96        def Set<TemplateField> giveFields() {
     97                return this.template.fields;
     98        }
     99
     100        @Override
     101        void setTemplate(Template newTemplate) {
     102
     103                // Contrary to expectation, this method does not cause an infinite loop but calls the super method
     104                // whereas super.setTemplate(newTemplate) leads to errors concerning NullObject values
     105                this.template = newTemplate
     106
     107                // TODO: initialize all template fields with the necessary keys and null values
     108
     109                println "Setting template " + newTemplate
     110                /*if (template == null || template instanceof NullObject) {} else{ // negation doesn't seem to work well
     111                        def stringFields = template.getFieldsByType(TemplateFieldType.STRINGLIST)
     112                        println stringFields*.name
     113                        if (stringFields.size() > 0) {
     114                                templateStringFields = new HashMap<String,String>()
     115                                templateStringFields.keyset.add stringFields*.name;
     116                                println templateStringFields
     117                        }
     118                }*/
     119        }
     120
    81121}
  • trunk/grails-app/domain/dbnp/studycapturing/TemplateField.groovy

    r190 r224  
    99 * $Date$
    1010 */
    11 abstract class TemplateField implements Serializable {
     11class TemplateField implements Serializable {
    1212        String name
    1313        TemplateFieldType type
     
    1515
    1616    static hasMany = [listEntries : String] // to store the entries to choose from when the type is 'item from predefined list'
     17        //TODO: make TemplateFieldListItem and make a convenience setter for a string array
    1718
    1819        static constraints = {
Note: See TracChangeset for help on using the changeset viewer.