Changeset 564


Ignore:
Timestamp:
Jun 14, 2010, 5:20:07 PM (9 years ago)
Author:
keesvb
Message:

fixed person problem in BootStrap?, added comments to Event class, fixed #104

Location:
trunk/grails-app
Files:
5 edited

Legend:

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

    r563 r564  
    6868
    6969                        // add Terms
    70                         println ".adding mouse term"
     70                        println ".adding terms"
    7171                        def mouseTerm = new Term(
    7272                                name: 'Mus musculus',
     
    7474                                accession: '10090'
    7575                        ).with { if (!validate()) { errors.each { println it} } else save()}
    76                         println ".adding human term"
     76
    7777                        def humanTerm = new Term(
    7878                                name: 'Homo sapiens',
     
    9999                        ).with { if (!validate()) { errors.each { println it} } else save()}
    100100
    101 
    102101                        def bloodTerm = new Term(
    103102                                name: 'blood plasma',
     
    118117                        ).with { if (!validate()) { errors.each { println it} } else save()}
    119118
    120                         if (GrailsUtil.environment == GrailsApplication.ENV_DEVELOPMENT) {
     119
     120            // Create templates
     121                        println ".adding templates"
     122
     123                        def genderField = new TemplateField(
     124                                name: 'Gender',type: TemplateFieldType.STRINGLIST, entity: Subject,
     125                                listEntries: [new TemplateFieldListItem(name:'Male'),new TemplateFieldListItem(name: 'Female'),new TemplateFieldListItem(name: 'Unknown')])
     126                        .with { if (!validate()) { errors.each { println it} } else save()}
     127
     128                        def ageField = new TemplateField(
     129                                name: 'Age',type: TemplateFieldType.INTEGER,entity: Subject,unit: 'years',comment: 'Either include age at the start of the study or date of birth (if known)')
     130                        .with { if (!validate()) { errors.each { println it} } else save()}
     131
     132                        def genotypeField = new TemplateField(
     133                                name: 'Genotype', type: TemplateFieldType.STRING,entity: Subject,
     134                                comment: 'If present, indicate the genetic variance of the subject (e.g., mutagenized populations,knock-out/in,transgene etc)')
     135                        .with { if (!validate()) { errors.each { println it} } else save()}
     136
     137                def genotypeTypeField = new TemplateField(
     138                                name: 'Genotype type',type: TemplateFieldType.STRINGLIST,entity: Subject,
     139                                listEntries: [new TemplateFieldListItem(name:'wildtype'),
     140                                        new TemplateFieldListItem(name:'transgenic'),
     141                                        new TemplateFieldListItem(name:'knock-out'),
     142                                        new TemplateFieldListItem(name:'knock-in')],
     143                                comment: 'If a genotype was specified, please indicate here the type of the genotype') 
     144                        .with { if (!validate()) { errors.each { println it} } else save()}
     145
     146                def varietyField = new TemplateField(
     147                                name: 'Variety', type: TemplateFieldType.STRING,entity: Subject,
     148                        comment: 'taxonomic category consisting of members of a species that differ from others of the same species in minor but heritable characteristics')
     149                        .with { if (!validate()) { errors.each { println it} } else save()}
     150
     151                        def ecotypeField = new TemplateField(
     152                        name: 'Ecotype', type: TemplateFieldType.STRING,entity: Subject,
     153                        comment: 'a type or subspecies of life that is especially well adapted to a certain environment'
     154                        )
     155                .with { if (!validate()) { errors.each { println it} } else save()}
     156
     157
     158                // Nutritional study template
     159                        println ".adding academic study template..."
     160                        def studyTemplate = new Template(
     161                                name: 'Academic study',
     162                                entity: dbnp.studycapturing.Study
     163                        )
     164                        .addToFields(new TemplateField(name: 'Description',type: TemplateFieldType.TEXT, entity: Study,comment:'Describe here the type of subjects and the treatment, challenges and sampling.'))
     165                        .addToFields(new TemplateField(name: 'Objectives',type: TemplateFieldType.TEXT,entity: Study,comment:'Fill out the aim or questions of the study'))
     166                        .addToFields(new TemplateField(name: 'Consortium',type: TemplateFieldType.STRING,entity: Study,comment:'If the study was performed within a consortium (e.g. NMC, NuGO), you can indicate this here'))
     167                        .addToFields(new TemplateField(name: 'Cohort name',type: TemplateFieldType.STRING,entity: Study,comment:'If a cohort was used the name or code of the cohort can be define here (define a cohort template)'))
     168                        .addToFields(new TemplateField(name: 'Lab id',type: TemplateFieldType.STRING,entity: Study,comment:'In which lab was the study performed; indicate the roomnumber.'))
     169                        .addToFields(new TemplateField(name: 'Institute',type: TemplateFieldType.STRING,entity: Study,comment:'In which institute was the study performed; indicate the full address information (to be replaced by persons-affiliations?)'))
     170                        .addToFields(new TemplateField(name: 'Study protocol',type: TemplateFieldType.FILE,entity: Study,comment:'Optionally attach a file in which the protocol in the study is described'))
     171                        .with { if (!validate()) { errors.each { println it} } else save()}
     172
     173                        // Mouse template
     174                        println ".adding mouse subject template..."
     175                        def mouseTemplate = new Template(
     176                                name: 'Mouse', entity: dbnp.studycapturing.Subject)
     177                        .addToFields(new TemplateField(
     178                                name: 'Strain', type: TemplateFieldType.ONTOLOGYTERM, ontologies: [nciOntology], entity: Subject, comment: "This is an ontology term, if the right strain is not in the list please add it with 'add more'"))
     179                        .addToFields(genotypeField)
     180                        .addToFields(genotypeTypeField)
     181                        .addToFields(genderField)
     182                        .addToFields(new TemplateField(
     183                                name: 'Age', type: TemplateFieldType.INTEGER, entity: Subject, unit: 'weeks', comment: 'Age at start of study'))
     184                        .addToFields(new TemplateField(
     185                                name: 'Age type',type: TemplateFieldType.STRINGLIST,entity: Subject,
     186                                listEntries: [new TemplateFieldListItem(name:'postnatal'),new TemplateFieldListItem(name:'embryonal')]))
     187                        .addToFields(new TemplateField(
     188                                name: 'Cage',type: TemplateFieldType.STRING,entity: Subject,comment:'Indicate the cage used for housing (type and/or size)'))
     189                        .addToFields(new TemplateField(
     190                                name: '#Mice in cage',type: TemplateFieldType.INTEGER,entity: Subject,comment:'If known, indicate the number of mice per cage'))
     191                        .addToFields(new TemplateField(
     192                                name: 'Litter size',type: TemplateFieldType.INTEGER,entity: Subject,comment:'If known, indicate the litter size of the litter from which the subject originates'))
     193                        .addToFields(new TemplateField(
     194                                name: 'Weight', type: TemplateFieldType.DOUBLE, unit: 'gram',entity: Subject,comment:'If known indicate the weight of the subject in grams at the start of the study'))
     195                        .with { if (!validate()) { errors.each { println it} } else save()}
     196
     197                        // Human template
     198                        println ".adding human subject template..."
     199                        def humanTemplate = new Template(
     200                                name: 'Human', entity: dbnp.studycapturing.Subject)
     201                        .addToFields(genderField)
     202                        .addToFields(ageField)
     203                        .addToFields(new TemplateField(
     204                                name: 'DOB',type: TemplateFieldType.DATE,entity: Subject,comment:'Date of birth'))
     205                        .addToFields(new TemplateField(
     206                                name: 'Height',type: TemplateFieldType.DOUBLE, entity: Subject, unit: 'm'))
     207                        .addToFields(new TemplateField(
     208                                name: 'Weight',type: TemplateFieldType.DOUBLE, entity: Subject, unit: 'kg'))
     209                        .addToFields(new TemplateField(
     210                                name: 'BMI',type: TemplateFieldType.DOUBLE, entity: Subject, unit: 'kg/m2',comment:'Body-mass-index'))
     211                        .addToFields(new TemplateField(
     212                                name: 'Race',type: TemplateFieldType.STRING,entity: Subject, comment:'If known and of interest the ethnic group can be indicated'))
     213                        .addToFields(new TemplateField(
     214                                name: 'Waist circumference',type: TemplateFieldType.FLOAT, unit: 'cm',entity: Subject, comment:'The waist circumference is measured just above the hip bone. Indicate the measure at the start of the study.'))
     215                        .addToFields(new TemplateField(
     216                                name: 'Hip circumference',type: TemplateFieldType.FLOAT, unit: 'cm',entity: Subject, comment:'The hip circumference is measured at the level of the two bony prominences front of the hips. Indicate the measure at the start of the study.'))
     217                        .addToFields(new TemplateField(
     218                                name: 'Systolic blood pressure',type: TemplateFieldType.FLOAT, unit: 'mmHg',entity: Subject, comment:'Indicate the levels at the start of the study in mmHG'))
     219                        .addToFields(new TemplateField(
     220                                name: 'Diastolic blood pressure',type: TemplateFieldType.FLOAT, unit: 'mmHg',entity: Subject, comment:'Indicate the levels at the start of the study in mmHG'))
     221                        .addToFields(new TemplateField(
     222                                name: 'Heart rate',type: TemplateFieldType.FLOAT, unit: 'beats/min',entity: Subject, comment:'Indicate the heart rate at the start of in study in beats per minute'))
     223                        .addToFields(new TemplateField(
     224                                name: 'Run-in-food',type: TemplateFieldType.TEXT,entity: Subject, comment:'If defined, give a short description of the food used before the measurements'))
     225                        .with { if (!validate()) { errors.each { println it} } else save()}
     226
     227                        println ".adding sample remarks field"
     228                        def sampleRemarksField = new TemplateField(
     229                                name: 'Remarks',
     230                                type: TemplateFieldType.TEXT,
     231                entity: Sample
     232                        )
     233                        .with { if (!validate()) { errors.each { println it} } else save()}
     234
     235                        println ".adding sample vial textfield"
     236                        def sampleVialTextField = new TemplateField(
     237                                name: 'Text on vial',
     238                                type: TemplateFieldType.STRING,
     239                entity: Sample
     240                        )
     241                        .with { if (!validate()) { errors.each { println it} } else save()}
     242
     243                        // Human tissue sample template
     244                        println ".adding human sample template..."
     245                        def humanSampleTemplate = new Template(
     246                                name: 'Human tissue sample',
     247                                entity: dbnp.studycapturing.Sample
     248                        )
     249                        .addToFields(sampleRemarksField)
     250                        .addToFields(sampleVialTextField)
     251            .addToFields(
     252                                new TemplateField(
     253                        name: 'Sample measured weight',
     254                        unit: 'mg',
     255                        type: TemplateFieldType.FLOAT,
     256                    entity: Sample
     257                                )
     258                        )
     259                        .with { if (!validate()) { errors.each { println it} } else save()}
     260
     261            // Human blood sample template
     262            println ".adding human sample template..."
     263            def humanBloodSampleTemplate = new Template(
     264                name: 'Human blood sample',
     265                                entity: dbnp.studycapturing.Sample
     266                        )
     267            .addToFields(sampleRemarksField)
     268            .addToFields(sampleVialTextField)
     269            .addToFields(
     270                                new TemplateField(
     271                        name: 'Sample measured volume',
     272                        unit: 'ml',
     273                        type: TemplateFieldType.FLOAT,
     274                                        entity: Sample
     275                                )
     276                        )
     277            .with { if (!validate()) { errors.each { println it} } else save()}
     278
     279                /*
     280            def GrowthTreatmentTemplate = new Template(
     281                                name: 'Growth treatment',
     282                                entity: dbnp.studycapturing.Event
     283                        )
     284                        .addToFields(sampleDescriptionField)
     285                        .addToFields(new TemplateField(name: 'position X',type: TemplateFieldType.STRING))
     286            .addToFields(new TemplateField(name: 'position Y',type: TemplateFieldType.STRING))
     287            .addToFields(new TemplateField(name: 'Block',type: TemplateFieldType.STRING))
     288            .addToFields(new TemplateField(name: 'Temparature Day',type: TemplateFieldType.STRING))
     289            .addToFields(new TemplateField(name: 'Temparature Night',type: TemplateFieldType.STRING))
     290            .addToFields(new TemplateField(name: 'Light Intensity',type: TemplateFieldType.STRING))
     291            .addToFields(new TemplateField(name: 'Harvest Delay',type: TemplateFieldType.STRING))
     292            .with { if (!validate()) { errors.each { println it} } else save()}
     293                */
     294
     295                        //Plant template
     296                        println ".adding geenhouse plant template..."
     297                        def greenHouseTemplate = new Template(
     298                                name: 'Plant-green house ',
     299                                entity: dbnp.studycapturing.Subject
     300                        )
     301                        .addToFields(varietyField)
     302                .addToFields(ecotypeField)
     303                .addToFields(genotypeField)
     304            /*
     305                        .addToFields(genotypeTypeField)
     306                        .addToFields(
     307                                new TemplateField(
     308                                        name: 'Growth location', type: TemplateFieldType.STRINGLIST,
     309                                        listEntries: [
     310                                                new TemplateFieldListItem(name:'Greenhouse'),
     311                                                new TemplateFieldListItem(name: 'Field')
     312                                        ]
     313                                )
     314                        )
     315                        .addToFields(
     316                                new TemplateField(
     317                                        name: 'Room', type: TemplateFieldType.STRING,
     318                                        comment: 'Chamber number in case of Greenhouse'
     319                                )
     320                        )
     321            */
     322                .addToFields(
     323                                new TemplateField(
     324                                        name: 'Chamber no.',
     325                                        type: TemplateFieldType.STRING,
     326                                        entity: Subject,
     327                                        comment: 'Chamber number in the Greenhouse'
     328                                )
     329                        )
     330                .addToFields(
     331                                new TemplateField(
     332                                        name: 'Growth type',
     333                                        entity: Subject,
     334                                        type: TemplateFieldType.STRINGLIST,
     335                                        listEntries: [
     336                                                new TemplateFieldListItem(name:'Standard'),
     337                        new TemplateFieldListItem(name: 'Experimental'),
     338                        new TemplateFieldListItem(name: 'Unknown')
     339                                        ]
     340                                )
     341                        )
     342                        .addToFields(new TemplateField(
     343                                name: 'Growth protocol', entity: Subject, type: TemplateFieldType.TEXT))
     344                .addToFields(new TemplateField(
     345                                name: 'Position X', entity: Subject, type: TemplateFieldType.FLOAT))
     346                        .addToFields(new TemplateField(
     347                                name: 'Position Y', entity: Subject, type: TemplateFieldType.FLOAT))
     348                        .addToFields(new TemplateField(
     349                                name: 'Block', entity: Subject, type: TemplateFieldType.STRING))
     350                        .addToFields(new TemplateField(
     351                                name: 'Temperature at day', entity: Subject, type: TemplateFieldType.FLOAT))
     352                        .addToFields(new TemplateField(
     353                                name: 'Temperature at night', entity: Subject, type: TemplateFieldType.FLOAT))
     354                        .addToFields(new TemplateField(
     355                                name: 'Photo period', entity: Subject, type: TemplateFieldType.STRING))
     356                        .addToFields(new TemplateField(
     357                                name: 'Light intensity', entity: Subject, type: TemplateFieldType.STRING))
     358                        .addToFields(new TemplateField(
     359                                name: 'Start date', entity: Subject, type: TemplateFieldType.DATE))
     360                        .addToFields(new TemplateField(
     361                                name: 'Harvest date', entity: Subject, type: TemplateFieldType.DATE))
     362                        .addToFields(new TemplateField(
     363                                name: 'Harvest delay', entity: Subject, type: TemplateFieldType.TEXT))
     364                        .addToFields(new TemplateField(
     365                                name: 'Additional info', entity: Subject, type: TemplateFieldType.TEXT))
     366                .with { if (!validate()) { errors.each { println it} } else save()}
     367
     368            println ".adding open-field plant template..."
     369                        def FieldTemplate = new Template(
     370                                name: 'Plant-open field',
     371                                entity: dbnp.studycapturing.Subject
     372                        )
     373                        .addToFields(varietyField)
     374                        .addToFields(ecotypeField)
     375                        .addToFields(genotypeField)
     376            .addToFields(new TemplateField(
     377                                name: 'Start date', entity: Subject, type: TemplateFieldType.DATE))
     378                        .addToFields(new TemplateField(
     379                                name: 'Harvest date', entity: Subject, type: TemplateFieldType.DATE))
     380                        .addToFields(new TemplateField(
     381                                name: 'Growth type', entity: Subject, type: TemplateFieldType.STRINGLIST,
     382                                listEntries: [new TemplateFieldListItem(name:'Standard'),new TemplateFieldListItem(name: 'Experimental')]))
     383                        .addToFields(new TemplateField(
     384                                name: 'Growth protocol', entity: Subject, type: TemplateFieldType.TEXT))
     385                        .addToFields(new TemplateField(
     386                                name: 'Harvest delay', entity: Subject, type: TemplateFieldType.TEXT))
     387                .with { if (!validate()) { errors.each { println it} } else save()}
     388
     389            //Plant template
     390                        println ".adding chamber plant template..."
     391                        def chamberTemplate = new Template(
     392                                name: 'Plant-chamber',
     393                                entity: dbnp.studycapturing.Subject
     394                        )
     395                        .addToFields(varietyField)
     396            .addToFields(ecotypeField)
     397            .addToFields(genotypeField)
     398                        /*
     399                        .addToFields(genotypeTypeField)
     400                        .addToFields(
     401                                new TemplateField(
     402                                        name: 'Growth location',
     403                                        type: TemplateFieldType.STRINGLIST,
     404                                        listEntries: [
     405                                                new TemplateFieldListItem(name:'Greenhouse'),
     406                                                new TemplateFieldListItem(name: 'Field')
     407                                        ]
     408                                )
     409                        )
     410                        */
     411                        .addToFields(new TemplateField(
     412                                name: 'Room', type: TemplateFieldType.STRING, entity: Subject,
     413                                comment: 'room number'))
     414                        .addToFields(new TemplateField(
     415                                name: 'Chamber no.', type: TemplateFieldType.STRING, entity: Subject,
     416                                comment: 'Chamber number'))
     417                        .addToFields(new TemplateField(
     418                                name: 'Block', type: TemplateFieldType.STRING, entity: Subject))
     419                        .addToFields(new TemplateField(
     420                                name: 'Position X', type: TemplateFieldType.FLOAT, entity: Subject))
     421                        .addToFields(new TemplateField(
     422                                name: 'Position Y', type: TemplateFieldType.FLOAT, entity: Subject))
     423                        .addToFields(new TemplateField(
     424                                name: 'Temperature at day', type: TemplateFieldType.FLOAT, entity: Subject))
     425                        .addToFields(new TemplateField(
     426                                name: 'Temperature at night', type: TemplateFieldType.FLOAT, entity: Subject))
     427                        .addToFields(new TemplateField(
     428                                name: 'Photo period', type: TemplateFieldType.STRING, entity: Subject))
     429                        .addToFields(new TemplateField(
     430                                name: 'Light intensity', type: TemplateFieldType.STRING, entity: Subject))
     431                        .addToFields(new TemplateField(
     432                                name: 'Start date', type: TemplateFieldType.DATE, entity: Subject))
     433                        .addToFields(new TemplateField(
     434                                name: 'Harvest date', type: TemplateFieldType.DATE, entity: Subject))
     435                        .addToFields(new TemplateField(
     436                                name: 'Growth type', type: TemplateFieldType.STRINGLIST, entity: Subject,
     437                                listEntries: [new TemplateFieldListItem(name:'Standard'),new TemplateFieldListItem(name: 'Experimental')]))
     438                        .addToFields(new TemplateField(
     439                                name: 'Growth protocol', type: TemplateFieldType.TEXT, entity: Subject))
     440                        .addToFields(new TemplateField(
     441                                name: 'Harvest delay', type: TemplateFieldType.TEXT, entity: Subject))
     442                        .with { if (!validate()) { errors.each { println it} } else save()}
     443
     444                        println ".adding plant sample template..."
     445                        def plantSampleTemplate = new Template(
     446                                name: 'Plant sample',
     447                                entity: dbnp.studycapturing.Sample
     448                        )
     449                        .addToFields(sampleRemarksField)
     450                        .addToFields(sampleVialTextField)
     451                        .with { if (!validate()) { errors.each { println it} } else save()}
     452
     453                        println ".adding material prep template"
     454                        def materialPrepTemplate = new Template(
     455                                name: 'Plant-material preparation',
     456                description: 'material preparation',
     457                entity: dbnp.studycapturing.Event
     458                        )
     459                        .addToFields(new TemplateField(
     460                                name: 'Tissue',
     461                                type: TemplateFieldType.STRING,
     462                                entity: Event,
     463                comment: 'organ/ fraction of culture/ plant part')
     464                        )
     465            .addToFields(
     466                                new TemplateField(
     467                                        name: 'Grinding',
     468                                        type: TemplateFieldType.STRINGLIST,
     469                                        entity: Event,
     470                        listEntries: [
     471                                                new TemplateFieldListItem(name:'yes'),
     472                            new TemplateFieldListItem(name: 'no'),
     473                            new TemplateFieldListItem(name: 'unknown')
     474                                        ]
     475                                )
     476                        )
     477                        .addToFields(
     478                                new TemplateField(
     479                                        name: 'Storage location',
     480                                        type: TemplateFieldType.STRING,
     481                                        entity: Event
     482                                )
     483                        )
     484                        .addToFields(
     485                                new TemplateField(
     486                                        name: 'protocol reference',
     487                                        type: TemplateFieldType.STRING,
     488                                        entity: Event
     489                                )
     490                        )
     491                        .with { if (!validate()) { errors.each { println it} } else save()}
     492
     493                        def protocolField = new TemplateField(
     494                                name: 'Protocol',
     495                                type: TemplateFieldType.FILE,
     496                                entity: Event,
     497                                comment: 'You can upload a protocol here which describes the procedure which was used when carrying out the event'
     498                        )
     499                        .with { if (!validate()) { errors.each { println it} } else save()}
     500
     501                        // diet treatment template
     502                        println ".adding diet treatement template"
     503                        def dietTreatmentTemplate = new Template(
     504                                name: 'Diet treatment',
     505                                entity: dbnp.studycapturing.Event
     506                        )
     507                        .addToFields(
     508                                new TemplateField(
     509                                        name: 'Diet',
     510                                        type: TemplateFieldType.STRINGLIST,
     511                                        entity: Event,
     512                                        listEntries: [
     513                                                new TemplateFieldListItem(name:'low fat'),
     514                                                new TemplateFieldListItem(name: 'high fat')
     515                                        ]
     516                                )
     517                        )
     518                        .addToFields(protocolField)
     519                        .with { if (!validate()) { errors.each { println it} } else save()}
     520
     521                        // boost treatment template
     522                        println ".adding boost treatment template"
     523                        def boostTreatmentTemplate = new Template(
     524                                name: 'Compound challenge',
     525                                entity: dbnp.studycapturing.Event
     526                        )
     527                        .addToFields(
     528                                new TemplateField(
     529                                        name: 'Compound',
     530                                        type: TemplateFieldType.ONTOLOGYTERM,
     531                                        entity: Event,
     532                                        ontologies: [chebiOntology]
     533                                )
     534                        )
     535                        .addToFields(
     536                                new TemplateField(
     537                                        name: 'Control',
     538                                        type: TemplateFieldType.BOOLEAN,
     539                                        entity: Event
     540                                )
     541                        )
     542                        .addToFields(protocolField)
     543                        .with { if (!validate()) { errors.each { println it} } else save()}
     544
     545                        // fasting treatment template
     546                        println ".adding fasting treatment template"
     547                        def fastingTreatment = new Template(
     548                                name: 'Fasting treatment',
     549                                description: 'Fasting for a specific amount of time',
     550                                entity: dbnp.studycapturing.Event
     551                        )
     552            .addToFields(
     553                                new TemplateField(
     554                                        name: 'Fasting period',
     555                                        type: TemplateFieldType.RELTIME,
     556                                        entity: Event
     557                                )
     558                        )
     559                        .with { if (!validate()) { errors.each { println it} } else save()}
     560
     561                        // SamplingEvent templates
     562                        println ".adding sampling protocol template field"
     563            def samplingProtocolField = new TemplateField(
     564                name: 'Sample Protocol',
     565                    entity: SamplingEvent,
     566                                type: TemplateFieldType.FILE,
     567                                comment: 'You can upload a protocol here which describes the procedure which was used when carrying out the sampling event'
     568                        )
     569            .with { if (!validate()) { errors.each { println it} } else save()}
     570
     571                        // liver sampling event template
     572                        println ".adding liver sampling event template"
     573                        def liverSamplingEventTemplate = new Template(
     574                                name: 'Liver extraction',
     575                                description: 'Liver sampling for transcriptomics arrays',
     576                                entity: dbnp.studycapturing.SamplingEvent
     577                        )
     578                        .addToFields(samplingProtocolField)
     579                        .addToFields(
     580                                new TemplateField(
     581                                        name: 'Sample weight',
     582                                        unit: 'mg',
     583                                        entity: SamplingEvent,
     584                                        type: TemplateFieldType.FLOAT
     585                                )
     586                        )
     587                        .with { if (!validate()) { errors.each { println it} } else save()}
     588
     589                        // blood sampling
     590                        println ".adding blood sampling event template"
     591                        def bloodSamplingEventTemplate = new Template(
     592                                name: 'Blood extraction',
     593                                description: 'Blood extraction targeted at lipid assays',
     594                        entity: dbnp.studycapturing.SamplingEvent
     595                        )
     596            .addToFields(samplingProtocolField)
     597                        .addToFields(
     598                                new TemplateField(
     599                                        name: 'Sample volume',
     600                                        entity: SamplingEvent,
     601                                        unit: 'ml',
     602                                        type: TemplateFieldType.FLOAT
     603                                )
     604                        )
     605                        .with { if (!validate()) { errors.each { println it} } else save()}
     606
     607                        // plant sample extraction event template
     608                        println ".adding plant sample extraction event template"
     609                        def plantSamplingExtractEventTemplate = new Template(
     610                                name: 'Plant sample extraction',
     611                                description: 'sample extraction',
     612                                entity: dbnp.studycapturing.SamplingEvent,
     613                sampleTemplates: [plantSampleTemplate]
     614                        )
     615            .addToFields(samplingProtocolField)
     616                        .addToFields(
     617                                new TemplateField(
     618                                        name: 'Sample weight',
     619                                        unit: 'ul',
     620                                        entity: SamplingEvent,
     621                                        type: TemplateFieldType.FLOAT
     622                                )
     623                        )
     624                        .addToFields(
     625                                new TemplateField(
     626                                        name: 'Sample when measured',
     627                                        type: TemplateFieldType.STRINGLIST,
     628                                        entity: SamplingEvent,
     629                        listEntries: [
     630                                                 new TemplateFieldListItem(name:'Dried'),
     631                         new TemplateFieldListItem(name: 'Fresh'),
     632                         new TemplateFieldListItem(name: 'Unknown')
     633                                         ]
     634                                )
     635                        )
     636                        .with { if (!validate()) { errors.each { println it} } else save()}
     637
     638                        // plant sampling event template
     639                        println ".adding plant sampling event template"
     640            def plantSamplingEventTemplate = new Template(
     641                                name: 'Plant-sample ',
     642                                description: 'plant sample ',
     643                                entity: dbnp.studycapturing.SamplingEvent,
     644                sampleTemplates: [plantSampleTemplate]
     645                        )
     646            //.addToFields(samplingProtocolField)
     647                        .addToFields(
     648                                new TemplateField(
     649                                        name: 'material',
     650                        comment: 'physical charecteristic. e.g, grounded powder of tomato seed or liquid',
     651                                        entity: SamplingEvent,
     652                                        type: TemplateFieldType.STRING
     653                                )
     654                        )
     655            .addToFields(
     656                                new TemplateField(
     657                                        name: 'Description',
     658                                        type: TemplateFieldType.STRING,
     659                                        entity: SamplingEvent
     660                                )
     661                        )
     662            .addToFields(
     663                                new TemplateField(
     664                                        name: 'extracted material',
     665                                        comment: 'substance to be extracted. e.g., lipids, volatiles, primary metabolites etc',
     666                                        type: TemplateFieldType.STRING,
     667                                        entity: SamplingEvent
     668                                )
     669                        )
     670            .addToFields(
     671                                new TemplateField(
     672                                        name: 'Text on vial',
     673                                        entity: SamplingEvent,
     674                                        type: TemplateFieldType.STRING
     675                                )
     676                        )
     677                        .with { if (!validate()) { errors.each { println it} } else save()}
     678
     679                        // Add example studies
     680                        if (grails.util.GrailsUtil.environment == GrailsApplication.ENV_DEVELOPMENT) {
    121681
    122682                                // Create a few persons, roles and Affiliations
     
    186746                                )
    187747                                .save();
    188                         }
    189 
    190             // Create templates
    191 
    192                         def genderField = new TemplateField(
    193                                 name: 'Gender',type: TemplateFieldType.STRINGLIST, entity: Subject,
    194                                 listEntries: [new TemplateFieldListItem(name:'Male'),new TemplateFieldListItem(name: 'Female'),new TemplateFieldListItem(name: 'Unknown')])
    195                         .with { if (!validate()) { errors.each { println it} } else save()}
    196 
    197                         def ageField = new TemplateField(
    198                                 name: 'Age',type: TemplateFieldType.INTEGER,entity: Subject,unit: 'years',comment: 'Either include age at the start of the study or date of birth (if known)')
    199                         .with { if (!validate()) { errors.each { println it} } else save()}
    200 
    201                         def genotypeField = new TemplateField(
    202                                 name: 'Genotype', type: TemplateFieldType.STRING,entity: Subject,
    203                                 comment: 'If present, indicate the genetic variance of the subject (e.g., mutagenized populations,knock-out/in,transgene etc)')
    204                         .with { if (!validate()) { errors.each { println it} } else save()}
    205 
    206                 def genotypeTypeField = new TemplateField(
    207                                 name: 'Genotype type',type: TemplateFieldType.STRINGLIST,entity: Subject,
    208                                 listEntries: [new TemplateFieldListItem(name:'wildtype'),
    209                                         new TemplateFieldListItem(name:'transgenic'),
    210                                         new TemplateFieldListItem(name:'knock-out'),
    211                                         new TemplateFieldListItem(name:'knock-in')],
    212                                 comment: 'If a genotype was specified, please indicate here the type of the genotype') 
    213                         .with { if (!validate()) { errors.each { println it} } else save()}
    214 
    215                 def varietyField = new TemplateField(
    216                                 name: 'Variety', type: TemplateFieldType.STRING,entity: Subject,
    217                         comment: 'taxonomic category consisting of members of a species that differ from others of the same species in minor but heritable characteristics')
    218                         .with { if (!validate()) { errors.each { println it} } else save()}
    219 
    220                         def ecotypeField = new TemplateField(
    221                         name: 'Ecotype', type: TemplateFieldType.STRING,entity: Subject,
    222                         comment: 'a type or subspecies of life that is especially well adapted to a certain environment'
    223                         )
    224                 .with { if (!validate()) { errors.each { println it} } else save()}
    225 
    226 
    227                 // Nutritional study template
    228                         println ".adding academic study template..."
    229                         def studyTemplate = new Template(
    230                                 name: 'Academic study',
    231                                 entity: dbnp.studycapturing.Study
    232                         )
    233                         .addToFields(new TemplateField(name: 'Description',type: TemplateFieldType.TEXT, entity: Study,comment:'Describe here the type of subjects and the treatment, challenges and sampling.'))
    234 /*
    235                         .addToFields(new TemplateField(
    236                                 name: 'Study code',
    237                                 type: TemplateFieldType.STRING,
    238                 entity: Study,
    239                                 preferredIdentifier:true,
    240                                 comment: 'Fill out the code by which many people will recognize your study')
    241                         )
    242 */
    243                         .addToFields(new TemplateField(name: 'Objectives',type: TemplateFieldType.TEXT,entity: Study,comment:'Fill out the aim or questions of the study'))
    244                         .addToFields(new TemplateField(name: 'Consortium',type: TemplateFieldType.STRING,entity: Study,comment:'If the study was performed within a consortium (e.g. NMC, NuGO), you can indicate this here'))
    245                         .addToFields(new TemplateField(name: 'Cohort name',type: TemplateFieldType.STRING,entity: Study,comment:'If a cohort was used the name or code of the cohort can be define here (define a cohort template)'))
    246                         .addToFields(new TemplateField(name: 'Lab id',type: TemplateFieldType.STRING,entity: Study,comment:'In which lab was the study performed; indicate the roomnumber.'))
    247                         .addToFields(new TemplateField(name: 'Institute',type: TemplateFieldType.STRING,entity: Study,comment:'In which institute was the study performed; indicate the full address information (to be replaced by persons-affiliations?)'))
    248                         .addToFields(new TemplateField(name: 'Study protocol',type: TemplateFieldType.FILE,entity: Study,comment:'Optionally attach a file in which the protocol in the study is described'))
    249                         .with { if (!validate()) { errors.each { println it} } else save()}
    250 
    251                         // Mouse template
    252                         println ".adding mouse subject template..."
    253                         def mouseTemplate = new Template(
    254                                 name: 'Mouse', entity: dbnp.studycapturing.Subject)
    255                         .addToFields(new TemplateField(
    256                                 name: 'Strain', type: TemplateFieldType.ONTOLOGYTERM, ontologies: [nciOntology], entity: Subject, comment: "This is an ontology term, if the right strain is not in the list please add it with 'add more'"))
    257                         .addToFields(genotypeField)
    258                         .addToFields(genotypeTypeField)
    259                         .addToFields(genderField)
    260                         .addToFields(new TemplateField(
    261                                 name: 'Age', type: TemplateFieldType.INTEGER, entity: Subject, unit: 'weeks', comment: 'Age at start of study'))
    262                         .addToFields(new TemplateField(
    263                                 name: 'Age type',type: TemplateFieldType.STRINGLIST,entity: Subject,
    264                                 listEntries: [new TemplateFieldListItem(name:'postnatal'),new TemplateFieldListItem(name:'embryonal')]))
    265                         .addToFields(new TemplateField(
    266                                 name: 'Cage',type: TemplateFieldType.STRING,entity: Subject,comment:'Indicate the cage used for housing (type and/or size)'))
    267                         .addToFields(new TemplateField(
    268                                 name: '#Mice in cage',type: TemplateFieldType.INTEGER,entity: Subject,comment:'If known, indicate the number of mice per cage'))
    269                         .addToFields(new TemplateField(
    270                                 name: 'Litter size',type: TemplateFieldType.INTEGER,entity: Subject,comment:'If known, indicate the litter size of the litter from which the subject originates'))
    271                         .addToFields(new TemplateField(
    272                                 name: 'Weight', type: TemplateFieldType.DOUBLE, unit: 'gram',entity: Subject,comment:'If known indicate the weight of the subject in grams at the start of the study'))
    273                         .with { if (!validate()) { errors.each { println it} } else save()}
    274 
    275                         // Human template
    276                         println ".adding human subject template..."
    277                         def humanTemplate = new Template(
    278                                 name: 'Human', entity: dbnp.studycapturing.Subject)
    279                         .addToFields(genderField)
    280                         .addToFields(ageField)
    281                         .addToFields(new TemplateField(
    282                                 name: 'DOB',type: TemplateFieldType.DATE,entity: Subject,comment:'Date of birth'))
    283                         .addToFields(new TemplateField(
    284                                 name: 'Height',type: TemplateFieldType.DOUBLE, entity: Subject, unit: 'm'))
    285                         .addToFields(new TemplateField(
    286                                 name: 'Weight',type: TemplateFieldType.DOUBLE, entity: Subject, unit: 'kg'))
    287                         .addToFields(new TemplateField(
    288                                 name: 'BMI',type: TemplateFieldType.DOUBLE, entity: Subject, unit: 'kg/m2',comment:'Body-mass-index'))
    289                         .addToFields(new TemplateField(
    290                                 name: 'Race',type: TemplateFieldType.STRING,entity: Subject, comment:'If known and of interest the ethnic group can be indicated'))
    291                         .addToFields(new TemplateField(
    292                                 name: 'Waist circumference',type: TemplateFieldType.FLOAT, unit: 'cm',entity: Subject, comment:'The waist circumference is measured just above the hip bone. Indicate the measure at the start of the study.'))
    293                         .addToFields(new TemplateField(
    294                                 name: 'Hip circumference',type: TemplateFieldType.FLOAT, unit: 'cm',entity: Subject, comment:'The hip circumference is measured at the level of the two bony prominences front of the hips. Indicate the measure at the start of the study.'))
    295                         .addToFields(new TemplateField(
    296                                 name: 'Systolic blood pressure',type: TemplateFieldType.FLOAT, unit: 'mmHg',entity: Subject, comment:'Indicate the levels at the start of the study in mmHG'))
    297                         .addToFields(new TemplateField(
    298                                 name: 'Diastolic blood pressure',type: TemplateFieldType.FLOAT, unit: 'mmHg',entity: Subject, comment:'Indicate the levels at the start of the study in mmHG'))
    299                         .addToFields(new TemplateField(
    300                                 name: 'Heart rate',type: TemplateFieldType.FLOAT, unit: 'beats/min',entity: Subject, comment:'Indicate the heart rate at the start of in study in beats per minute'))
    301                         .addToFields(new TemplateField(
    302                                 name: 'Run-in-food',type: TemplateFieldType.TEXT,entity: Subject, comment:'If defined, give a short description of the food used before the measurements'))
    303                         .with { if (!validate()) { errors.each { println it} } else save()}
    304 
    305                         println ".adding sample remarks field"
    306                         def sampleRemarksField = new TemplateField(
    307                                 name: 'Remarks',
    308                                 type: TemplateFieldType.TEXT,
    309                 entity: Sample
    310                         )
    311                         .with { if (!validate()) { errors.each { println it} } else save()}
    312 
    313                         println ".adding sample vial textfield"
    314                         def sampleVialTextField = new TemplateField(
    315                                 name: 'Text on vial',
    316                                 type: TemplateFieldType.STRING,
    317                 entity: Sample
    318                         )
    319                         .with { if (!validate()) { errors.each { println it} } else save()}
    320 
    321                         // Human tissue sample template
    322                         println ".adding human sample template..."
    323                         def humanSampleTemplate = new Template(
    324                                 name: 'Human tissue sample',
    325                                 entity: dbnp.studycapturing.Sample
    326                         )
    327                         .addToFields(sampleRemarksField)
    328                         .addToFields(sampleVialTextField)
    329             .addToFields(
    330                                 new TemplateField(
    331                         name: 'Sample measured weight',
    332                         unit: 'mg',
    333                         type: TemplateFieldType.FLOAT,
    334                     entity: Sample
    335                                 )
    336                         )
    337                         .with { if (!validate()) { errors.each { println it} } else save()}
    338 
    339             // Human blood sample template
    340             println ".adding human sample template..."
    341             def humanBloodSampleTemplate = new Template(
    342                 name: 'Human blood sample',
    343                                 entity: dbnp.studycapturing.Sample
    344                         )
    345             .addToFields(sampleRemarksField)
    346             .addToFields(sampleVialTextField)
    347             .addToFields(
    348                                 new TemplateField(
    349                         name: 'Sample measured volume',
    350                         unit: 'ml',
    351                         type: TemplateFieldType.FLOAT,
    352                                         entity: Sample
    353                                 )
    354                         )
    355             .with { if (!validate()) { errors.each { println it} } else save()}
    356 
    357                 /*
    358             def GrowthTreatmentTemplate = new Template(
    359                                 name: 'Growth treatment',
    360                                 entity: dbnp.studycapturing.Event
    361                         )
    362                         .addToFields(sampleDescriptionField)
    363                         .addToFields(new TemplateField(name: 'position X',type: TemplateFieldType.STRING))
    364             .addToFields(new TemplateField(name: 'position Y',type: TemplateFieldType.STRING))
    365             .addToFields(new TemplateField(name: 'Block',type: TemplateFieldType.STRING))
    366             .addToFields(new TemplateField(name: 'Temparature Day',type: TemplateFieldType.STRING))
    367             .addToFields(new TemplateField(name: 'Temparature Night',type: TemplateFieldType.STRING))
    368             .addToFields(new TemplateField(name: 'Light Intensity',type: TemplateFieldType.STRING))
    369             .addToFields(new TemplateField(name: 'Harvest Delay',type: TemplateFieldType.STRING))
    370             .with { if (!validate()) { errors.each { println it} } else save()}
    371                 */
    372 
    373                         //Plant template
    374                         println ".adding geenhouse plant template..."
    375                         def greenHouseTemplate = new Template(
    376                                 name: 'Plant-green house ',
    377                                 entity: dbnp.studycapturing.Subject
    378                         )
    379                         .addToFields(varietyField)
    380                 .addToFields(ecotypeField)
    381                 .addToFields(genotypeField)
    382             /*
    383                         .addToFields(genotypeTypeField)
    384                         .addToFields(
    385                                 new TemplateField(
    386                                         name: 'Growth location', type: TemplateFieldType.STRINGLIST,
    387                                         listEntries: [
    388                                                 new TemplateFieldListItem(name:'Greenhouse'),
    389                                                 new TemplateFieldListItem(name: 'Field')
    390                                         ]
    391                                 )
    392                         )
    393                         .addToFields(
    394                                 new TemplateField(
    395                                         name: 'Room', type: TemplateFieldType.STRING,
    396                                         comment: 'Chamber number in case of Greenhouse'
    397                                 )
    398                         )
    399             */
    400                 .addToFields(
    401                                 new TemplateField(
    402                                         name: 'Chamber no.',
    403                                         type: TemplateFieldType.STRING,
    404                                         entity: Subject,
    405                                         comment: 'Chamber number in the Greenhouse'
    406                                 )
    407                         )
    408                 .addToFields(
    409                                 new TemplateField(
    410                                         name: 'Growth type',
    411                                         entity: Subject,
    412                                         type: TemplateFieldType.STRINGLIST,
    413                                         listEntries: [
    414                                                 new TemplateFieldListItem(name:'Standard'),
    415                         new TemplateFieldListItem(name: 'Experimental'),
    416                         new TemplateFieldListItem(name: 'Unknown')
    417                                         ]
    418                                 )
    419                         )
    420                         .addToFields(new TemplateField(
    421                                 name: 'Growth protocol', entity: Subject, type: TemplateFieldType.TEXT))
    422                 .addToFields(new TemplateField(
    423                                 name: 'Position X', entity: Subject, type: TemplateFieldType.FLOAT))
    424                         .addToFields(new TemplateField(
    425                                 name: 'Position Y', entity: Subject, type: TemplateFieldType.FLOAT))
    426                         .addToFields(new TemplateField(
    427                                 name: 'Block', entity: Subject, type: TemplateFieldType.STRING))
    428                         .addToFields(new TemplateField(
    429                                 name: 'Temperature at day', entity: Subject, type: TemplateFieldType.FLOAT))
    430                         .addToFields(new TemplateField(
    431                                 name: 'Temperature at night', entity: Subject, type: TemplateFieldType.FLOAT))
    432                         .addToFields(new TemplateField(
    433                                 name: 'Photo period', entity: Subject, type: TemplateFieldType.STRING))
    434                         .addToFields(new TemplateField(
    435                                 name: 'Light intensity', entity: Subject, type: TemplateFieldType.STRING))
    436                         .addToFields(new TemplateField(
    437                                 name: 'Start date', entity: Subject, type: TemplateFieldType.DATE))
    438                         .addToFields(new TemplateField(
    439                                 name: 'Harvest date', entity: Subject, type: TemplateFieldType.DATE))
    440                         .addToFields(new TemplateField(
    441                                 name: 'Harvest delay', entity: Subject, type: TemplateFieldType.TEXT))
    442                         .addToFields(new TemplateField(
    443                                 name: 'Additional info', entity: Subject, type: TemplateFieldType.TEXT))
    444                 .with { if (!validate()) { errors.each { println it} } else save()}
    445 
    446             println ".adding open-field plant template..."
    447                         def FieldTemplate = new Template(
    448                                 name: 'Plant-open field',
    449                                 entity: dbnp.studycapturing.Subject
    450                         )
    451                         .addToFields(varietyField)
    452                         .addToFields(ecotypeField)
    453                         .addToFields(genotypeField)
    454             .addToFields(new TemplateField(
    455                                 name: 'Start date', entity: Subject, type: TemplateFieldType.DATE))
    456                         .addToFields(new TemplateField(
    457                                 name: 'Harvest date', entity: Subject, type: TemplateFieldType.DATE))
    458                         .addToFields(new TemplateField(
    459                                 name: 'Growth type', entity: Subject, type: TemplateFieldType.STRINGLIST,
    460                                 listEntries: [new TemplateFieldListItem(name:'Standard'),new TemplateFieldListItem(name: 'Experimental')]))
    461                         .addToFields(new TemplateField(
    462                                 name: 'Growth protocol', entity: Subject, type: TemplateFieldType.TEXT))
    463                         .addToFields(new TemplateField(
    464                                 name: 'Harvest delay', entity: Subject, type: TemplateFieldType.TEXT))
    465                 .with { if (!validate()) { errors.each { println it} } else save()}
    466 
    467             //Plant template
    468                         println ".adding chamber plant template..."
    469                         def chamberTemplate = new Template(
    470                                 name: 'Plant-chamber',
    471                                 entity: dbnp.studycapturing.Subject
    472                         )
    473                         .addToFields(varietyField)
    474             .addToFields(ecotypeField)
    475             .addToFields(genotypeField)
    476                         /*
    477                         .addToFields(genotypeTypeField)
    478                         .addToFields(
    479                                 new TemplateField(
    480                                         name: 'Growth location',
    481                                         type: TemplateFieldType.STRINGLIST,
    482                                         listEntries: [
    483                                                 new TemplateFieldListItem(name:'Greenhouse'),
    484                                                 new TemplateFieldListItem(name: 'Field')
    485                                         ]
    486                                 )
    487                         )
    488                         */
    489                         .addToFields(new TemplateField(
    490                                 name: 'Room', type: TemplateFieldType.STRING, entity: Subject,
    491                                 comment: 'room number'))
    492                         .addToFields(new TemplateField(
    493                                 name: 'Chamber no.', type: TemplateFieldType.STRING, entity: Subject,
    494                                 comment: 'Chamber number'))
    495                         .addToFields(new TemplateField(
    496                                 name: 'Block', type: TemplateFieldType.STRING, entity: Subject))
    497                         .addToFields(new TemplateField(
    498                                 name: 'Position X', type: TemplateFieldType.FLOAT, entity: Subject))
    499                         .addToFields(new TemplateField(
    500                                 name: 'Position Y', type: TemplateFieldType.FLOAT, entity: Subject))
    501                         .addToFields(new TemplateField(
    502                                 name: 'Temperature at day', type: TemplateFieldType.FLOAT, entity: Subject))
    503                         .addToFields(new TemplateField(
    504                                 name: 'Temperature at night', type: TemplateFieldType.FLOAT, entity: Subject))
    505                         .addToFields(new TemplateField(
    506                                 name: 'Photo period', type: TemplateFieldType.STRING, entity: Subject))
    507                         .addToFields(new TemplateField(
    508                                 name: 'Light intensity', type: TemplateFieldType.STRING, entity: Subject))
    509                         .addToFields(new TemplateField(
    510                                 name: 'Start date', type: TemplateFieldType.DATE, entity: Subject))
    511                         .addToFields(new TemplateField(
    512                                 name: 'Harvest date', type: TemplateFieldType.DATE, entity: Subject))
    513                         .addToFields(new TemplateField(
    514                                 name: 'Growth type', type: TemplateFieldType.STRINGLIST, entity: Subject,
    515                                 listEntries: [new TemplateFieldListItem(name:'Standard'),new TemplateFieldListItem(name: 'Experimental')]))
    516                         .addToFields(new TemplateField(
    517                                 name: 'Growth protocol', type: TemplateFieldType.TEXT, entity: Subject))
    518                         .addToFields(new TemplateField(
    519                                 name: 'Harvest delay', type: TemplateFieldType.TEXT, entity: Subject))
    520                         .with { if (!validate()) { errors.each { println it} } else save()}
    521 
    522                         println ".adding plant sample template..."
    523                         def plantSampleTemplate = new Template(
    524                                 name: 'Plant sample',
    525                                 entity: dbnp.studycapturing.Sample
    526                         )
    527                         .addToFields(sampleRemarksField)
    528                         .addToFields(sampleVialTextField)
    529                         .with { if (!validate()) { errors.each { println it} } else save()}
    530 
    531                         println ".adding material prep template"
    532                         def materialPrepTemplate = new Template(
    533                                 name: 'Plant-material preparation',
    534                 description: 'material preparation',
    535                 entity: dbnp.studycapturing.Event
    536                         )
    537                         .addToFields(new TemplateField(
    538                                 name: 'Tissue',
    539                                 type: TemplateFieldType.STRING,
    540                                 entity: Event,
    541                 comment: 'organ/ fraction of culture/ plant part')
    542                         )
    543             .addToFields(
    544                                 new TemplateField(
    545                                         name: 'Grinding',
    546                                         type: TemplateFieldType.STRINGLIST,
    547                                         entity: Event,
    548                         listEntries: [
    549                                                 new TemplateFieldListItem(name:'yes'),
    550                             new TemplateFieldListItem(name: 'no'),
    551                             new TemplateFieldListItem(name: 'unknown')
    552                                         ]
    553                                 )
    554                         )
    555                         .addToFields(
    556                                 new TemplateField(
    557                                         name: 'Storage location',
    558                                         type: TemplateFieldType.STRING,
    559                                         entity: Event
    560                                 )
    561                         )
    562                         .addToFields(
    563                                 new TemplateField(
    564                                         name: 'protocol reference',
    565                                         type: TemplateFieldType.STRING,
    566                                         entity: Event
    567                                 )
    568                         )
    569                         .with { if (!validate()) { errors.each { println it} } else save()}
    570 
    571                         def protocolField = new TemplateField(
    572                                 name: 'Protocol',
    573                                 type: TemplateFieldType.FILE,
    574                                 entity: Event,
    575                                 comment: 'You can upload a protocol here which describes the procedure which was used when carrying out the event'
    576                         )
    577                         .with { if (!validate()) { errors.each { println it} } else save()}
    578 
    579                         // diet treatment template
    580                         println ".adding diet treatement template"
    581                         def dietTreatmentTemplate = new Template(
    582                                 name: 'Diet treatment',
    583                                 entity: dbnp.studycapturing.Event
    584                         )
    585                         .addToFields(
    586                                 new TemplateField(
    587                                         name: 'Diet',
    588                                         type: TemplateFieldType.STRINGLIST,
    589                                         entity: Event,
    590                                         listEntries: [
    591                                                 new TemplateFieldListItem(name:'low fat'),
    592                                                 new TemplateFieldListItem(name: 'high fat')
    593                                         ]
    594                                 )
    595                         )
    596                         .addToFields(protocolField)
    597                         .with { if (!validate()) { errors.each { println it} } else save()}
    598 
    599                         // boost treatment template
    600                         println ".adding boost treatment template"
    601                         def boostTreatmentTemplate = new Template(
    602                                 name: 'Compound challenge',
    603                                 entity: dbnp.studycapturing.Event
    604                         )
    605                         .addToFields(
    606                                 new TemplateField(
    607                                         name: 'Compound',
    608                                         type: TemplateFieldType.ONTOLOGYTERM,
    609                                         entity: Event,
    610                                         ontologies: [chebiOntology]
    611                                 )
    612                         )
    613                         .addToFields(
    614                                 new TemplateField(
    615                                         name: 'Control',
    616                                         type: TemplateFieldType.BOOLEAN,
    617                                         entity: Event
    618                                 )
    619                         )
    620                         .addToFields(protocolField)
    621                         .with { if (!validate()) { errors.each { println it} } else save()}
    622 
    623                         // fasting treatment template
    624                         println ".adding fasting treatment template"
    625                         def fastingTreatment = new Template(
    626                                 name: 'Fasting treatment',
    627                                 description: 'Fasting for a specific amount of time',
    628                                 entity: dbnp.studycapturing.Event
    629                         )
    630             .addToFields(
    631                                 new TemplateField(
    632                                         name: 'Fasting period',
    633                                         type: TemplateFieldType.RELTIME,
    634                                         entity: Event
    635                                 )
    636                         )
    637                         .with { if (!validate()) { errors.each { println it} } else save()}
    638 
    639                         // SamplingEvent templates
    640                         println ".adding sampling protocol template field"
    641             def samplingProtocolField = new TemplateField(
    642                 name: 'Sample Protocol',
    643                     entity: SamplingEvent,
    644                                 type: TemplateFieldType.FILE,
    645                                 comment: 'You can upload a protocol here which describes the procedure which was used when carrying out the sampling event'
    646                         )
    647             .with { if (!validate()) { errors.each { println it} } else save()}
    648 
    649                         // liver sampling event template
    650                         println ".adding liver sampling event template"
    651                         def liverSamplingEventTemplate = new Template(
    652                                 name: 'Liver extraction',
    653                                 description: 'Liver sampling for transcriptomics arrays',
    654                                 entity: dbnp.studycapturing.SamplingEvent
    655                         )
    656                         .addToFields(samplingProtocolField)
    657                         .addToFields(
    658                                 new TemplateField(
    659                                         name: 'Sample weight',
    660                                         unit: 'mg',
    661                                         entity: SamplingEvent,
    662                                         type: TemplateFieldType.FLOAT
    663                                 )
    664                         )
    665                         .with { if (!validate()) { errors.each { println it} } else save()}
    666 
    667                         // blood sampling
    668                         println ".adding blood sampling event template"
    669                         def bloodSamplingEventTemplate = new Template(
    670                                 name: 'Blood extraction',
    671                                 description: 'Blood extraction targeted at lipid assays',
    672                         entity: dbnp.studycapturing.SamplingEvent
    673                         )
    674             .addToFields(samplingProtocolField)
    675                         .addToFields(
    676                                 new TemplateField(
    677                                         name: 'Sample volume',
    678                                         entity: SamplingEvent,
    679                                         unit: 'ml',
    680                                         type: TemplateFieldType.FLOAT
    681                                 )
    682                         )
    683                         .with { if (!validate()) { errors.each { println it} } else save()}
    684 
    685                         // plant sample extraction event template
    686                         println ".adding plant sample extraction event template"
    687                         def plantSamplingExtractEventTemplate = new Template(
    688                                 name: 'Plant sample extraction',
    689                                 description: 'sample extraction',
    690                                 entity: dbnp.studycapturing.SamplingEvent,
    691                 sampleTemplates: [plantSampleTemplate]
    692                         )
    693             .addToFields(samplingProtocolField)
    694                         .addToFields(
    695                                 new TemplateField(
    696                                         name: 'Sample weight',
    697                                         unit: 'ul',
    698                                         entity: SamplingEvent,
    699                                         type: TemplateFieldType.FLOAT
    700                                 )
    701                         )
    702                         .addToFields(
    703                                 new TemplateField(
    704                                         name: 'Sample when measured',
    705                                         type: TemplateFieldType.STRINGLIST,
    706                                         entity: SamplingEvent,
    707                         listEntries: [
    708                                                  new TemplateFieldListItem(name:'Dried'),
    709                          new TemplateFieldListItem(name: 'Fresh'),
    710                          new TemplateFieldListItem(name: 'Unknown')
    711                                          ]
    712                                 )
    713                         )
    714                         .with { if (!validate()) { errors.each { println it} } else save()}
    715 
    716                         // plant sampling event template
    717                         println ".adding plant sampling event template"
    718             def plantSamplingEventTemplate = new Template(
    719                                 name: 'Plant-sample ',
    720                                 description: 'plant sample ',
    721                                 entity: dbnp.studycapturing.SamplingEvent,
    722                 sampleTemplates: [plantSampleTemplate]
    723                         )
    724             //.addToFields(samplingProtocolField)
    725                         .addToFields(
    726                                 new TemplateField(
    727                                         name: 'material',
    728                         comment: 'physical charecteristic. e.g, grounded powder of tomato seed or liquid',
    729                                         entity: SamplingEvent,
    730                                         type: TemplateFieldType.STRING
    731                                 )
    732                         )
    733             .addToFields(
    734                                 new TemplateField(
    735                                         name: 'Description',
    736                                         type: TemplateFieldType.STRING,
    737                                         entity: SamplingEvent
    738                                 )
    739                         )
    740             .addToFields(
    741                                 new TemplateField(
    742                                         name: 'extracted material',
    743                                         comment: 'substance to be extracted. e.g., lipids, volatiles, primary metabolites etc',
    744                                         type: TemplateFieldType.STRING,
    745                                         entity: SamplingEvent
    746                                 )
    747                         )
    748             .addToFields(
    749                                 new TemplateField(
    750                                         name: 'Text on vial',
    751                                         entity: SamplingEvent,
    752                                         type: TemplateFieldType.STRING
    753                                 )
    754                         )
    755                         .with { if (!validate()) { errors.each { println it} } else save()}
    756 
    757                         // Add example studies
    758                         if (grails.util.GrailsUtil.environment == GrailsApplication.ENV_DEVELOPMENT) {
     748
     749                                // Add example mouse study
    759750                                println ".adding NuGO PPS3 leptin example study..."
    760751                                def mouseStudy = new Study(
     
    962953                                .save()
    963954
     955                                // Add example human study
    964956                                println ".adding NuGO PPSH example study..."
    965957
  • trunk/grails-app/domain/dbnp/studycapturing/Event.groovy

    r541 r564  
    4545        static List<TemplateField> giveDomainFields() { return Event.domainFields }
    4646
    47         // TODO: Kees start documenting your code
    4847        static final List<TemplateField> domainFields = [
    4948                new TemplateField(
    5049                        name: 'startTime',
    51                         type: TemplateFieldType.RELTIME),
     50                        type: TemplateFieldType.RELTIME,
     51                        comment: "Please enter the start time as a relative time from study start date. "+RelTime.getHelpText()),
    5252                new TemplateField(
    5353                        name: 'endTime',
    54                         type: TemplateFieldType.RELTIME)
     54                        type: TemplateFieldType.RELTIME,
     55                        comment: "Please enter the end time as a relative time from study start date. "+RelTime.getHelpText())
    5556        ]
    5657
     58        // TODO: Jahn, could you indicate in a comment why these different duration functions exist?
    5759        def getDuration() {
    5860                return new RelTime(startTime, endTime);
     
    6769        }
    6870
    69         // TODO: Kees start documenting your code
    7071        def getPrettyDuration() {
    7172                getPrettyDuration(getDuration())
    7273        }
    7374
    74         // TODO: Kees start documenting your code
    7575        def getDurationString() {
    7676                def d = getDuration()
     
    7878        }
    7979
    80         // TODO: Kees start documenting your code
    8180        def getShortDuration() {
    8281                def d = getDuration()
     
    8483        }
    8584
    86         // TODO: Kees start documenting your code
     85        /**
     86         *    Return whether this is SamplingEvent
     87         * @return    boolean
     88         */
    8789        def isSamplingEvent() {
    8890                return (this instanceof SamplingEvent)
    8991        }
    9092
    91         // TODO: Kees start documenting your code
    9293        def belongsToGroup(Set<EventGroup> groups) {
    9394                def eventFound = false;
     
    102103        }
    103104
    104         // TODO: Kees start documenting your code
    105105        def String toString() {
    106106                return fieldExists('Description') ? getFieldValue('Description') : ""
  • trunk/grails-app/domain/dbnp/studycapturing/RelTime.groovy

    r540 r564  
    167167        }
    168168
     169
     170
     171         /**
     172          * Return a sentence that may be used in interfaces to give the user an instruction on how to enter RelTimes in string format
     173         */
     174        public static final String getHelpText() {
     175                return "Use the first letter of weeks/days/hours/minutes/seconds, e.g. '1w 2d' for 1 week + 2 days or '10m30s for 10 minutes and 30 seconds.";
     176        }
     177
    169178        /**
    170179         * Parses a string into a RelTime long
  • trunk/grails-app/domain/dbnp/studycapturing/Study.groovy

    r554 r564  
    1717        Date lastUpdated
    1818        Date startDate
    19    
    20 
    21         /**
    22          * return the domain fields for this domain class
    23          * @return List
    24          */
    25         static List<TemplateField> giveDomainFields() { return Study.domainFields }
    26 
    27         static final List<TemplateField> domainFields = [
    28                 new TemplateField(
    29                         name: 'title',
    30                         type: TemplateFieldType.STRING),
    31                 new TemplateField(
    32                         name: 'code',
    33                         type: TemplateFieldType.STRING,
    34                         preferredIdentifier:true,
    35                         comment: 'Fill out the code by which many people will recognize your study'),
    36                 new TemplateField(
    37                         name: 'startDate',
    38                         type: TemplateFieldType.DATE,
    39                         comment: 'Fill out the official start date or date of first action')
    40         ]
     19    List subjects
     20        List events
     21        List samplingEvents
     22        List eventGroups
     23        List samples
     24        List assays
    4125
    4226        static hasMany = [
     
    6347                autoTimestamp true
    6448        }
     49
     50        /**
     51         * return the domain fields for this domain class
     52         * @return List
     53         */
     54        static List<TemplateField> giveDomainFields() { return Study.domainFields }
     55
     56        static final List<TemplateField> domainFields = [
     57                new TemplateField(
     58                        name: 'title',
     59                        type: TemplateFieldType.STRING),
     60                new TemplateField(
     61                        name: 'code',
     62                        type: TemplateFieldType.STRING,
     63                        preferredIdentifier:true,
     64                        comment: 'Fill out the code by which many people will recognize your study'),
     65                new TemplateField(
     66                        name: 'startDate',
     67                        type: TemplateFieldType.DATE,
     68                        comment: 'Fill out the official start date or date of first action')
     69        ]
    6570
    6671        /**
  • trunk/grails-app/domain/dbnp/studycapturing/TemplateEntity.groovy

    r561 r564  
    420420                // Convenience setter for boolean fields
    421421                if( field.type == TemplateFieldType.BOOLEAN && value && value.class == String ) {
    422                         if (value.equals("true")) {
     422                        if (value.equals("true") || value.equals("on")) {
    423423                                value = true
    424424                        }
    425                         else if (value.equals("false")) {
     425                        else if (value.equals("false") || value.equals("off")) {
    426426                                value = false
    427427                        }
Note: See TracChangeset for help on using the changeset viewer.