source: trunk/grails-app/conf/BootStrap.groovy @ 497

Last change on this file since 497 was 497, checked in by roberth, 9 years ago

Implemented RELTIME parsing and showing in the wizard.
Also made TEXT templatefields to show a textarea

  • Property svn:keywords set to Author Rev Date
File size: 30.9 KB
RevLine 
[92]1import dbnp.studycapturing.*
[15]2
[106]3import dbnp.data.Ontology
4import dbnp.data.Term
[406]5import org.codehaus.groovy.grails.commons.GrailsApplication
[106]6
[15]7/**
8 * Application Bootstrapper
[92]9 * @Author Jeroen Wesbeek
10 * @Since 20091021
[15]11 *
12 * Revision information:
13 * $Rev: 497 $
14 * $Author: roberth $
15 * $Date: 2010-05-28 14:19:06 +0000 (vr, 28 mei 2010) $
16 */
[4]17class BootStrap {
[92]18        def init = {servletContext ->
[138]19                // define timezone
[246]20                System.setProperty('user.timezone', 'CET')
[95]21
[266]22                // we could also check if we are in development by GrailsUtil.environment == GrailsApplication.ENV_DEVELOPMENT
23                if (Study.count() == 0) {
[360]24                        println ".development bootstrapping...";
[347]25
[421]26                        // add Subject>species ontology
[353]27                        println ".adding NCBI species ontology"
28                        def speciesOntology = new Ontology(
29                                name: 'NCBI organismal classification',
30                                description: 'A taxonomic classification of living organisms and associated artifacts for their controlled description within the context of databases.',
31                                url: 'http://www.ncbi.nlm.nih.gov/Taxonomy/taxonomyhome.html/',
32                                versionNumber: '1.2',
33                                ncboId: '1132',
34                                ncboVersionedId: '38802'
35                        ).with { if (!validate()) { errors.each { println it} } else save()}
[349]36
[421]37                        // add Sample>material ontology
[394]38                        println ".adding BRENDA source material ontology"
39                        def brendaOntology = new Ontology(
40                                name: 'BRENDA tissue / enzyme source',
41                                description: 'A structured controlled vocabulary for the source of an enzyme. It comprises terms for tissues, cell lines, cell types and cell cultures from uni- and multicellular organisms.',
42                                url: 'http://www.brenda-enzymes.info',
43                                versionNumber: '1.3',
44                                ncboId: '1005',
45                                ncboVersionedId: '40643'
46                        ).with { if (!validate()) { errors.each { println it} } else save()}
47
[421]48                        // add NCI ontology which is used in Mouse genotype template field
[339]49                        def nciOntology = new Ontology(
50                                name: 'NCI Thesaurus',
[421]51                                description: 'A vocabulary for clinical care, translational and basic research, and public information and administrative activities.',
52                                url: 'http://ncicb.nci.nih.gov/core/EVS',
53                                versionNumber: '10.01',
54                                ncboId: '1032',
55                                ncboVersionedId: '42693'
[339]56                        ).with { if (!validate()) { errors.each { println it} } else save()}
[421]57                       
58                        // add Terms
59                        println ".adding mouse term"
[92]60                        def mouseTerm = new Term(
61                                name: 'Mus musculus',
62                                ontology: speciesOntology,
63                                accession: '10090'
[139]64                        ).with { if (!validate()) { errors.each { println it} } else save()}
[421]65                        println ".adding human term"
[92]66                        def humanTerm = new Term(
67                                name: 'Homo sapiens',
68                                ontology: speciesOntology,
69                                accession: '9606'
[139]70                        ).with { if (!validate()) { errors.each { println it} } else save()}
[339]71                        def arabTerm = new Term(
72                                name: 'Arabidopsis thaliana',
73                                ontology: speciesOntology,
74                                accession: '3702'
75                        ).with { if (!validate()) { errors.each { println it} } else save()}
[421]76
[389]77                        def bloodTerm = new Term(
[421]78                                name: 'blood plasma',
79                                ontology: brendaOntology,
80                                accession: 'BTO:0000131'
[389]81                        ).with { if (!validate()) { errors.each { println it} } else save()}
[186]82
[339]83                        def c57bl6Term = new Term(
84                                name: 'C57BL/6 Mouse',
85                                ontology: nciOntology,
86                                accession: 'C14424'
87                        ).with { if (!validate()) { errors.each { println it} } else save()}
88
[421]89                        // Create a few persons, roles and Affiliations
90                        println ".adding persons, roles and affiliations"
91                        def affiliation1 = new PersonAffiliation(
[442]92                            institute: "Science Institute NYC",
93                            department: "Department of Mathematics"
[421]94                        ).save();
95                        def affiliation2 = new PersonAffiliation(
[442]96                            institute: "InfoStats GmbH, Hamburg",
97                            department: "Life Sciences"
[421]98                        ).save();
99                        def role1 = new PersonRole(
100                            name: "Principal Investigator"
101                        ).save();
102                        def role2 = new PersonRole(
103                            name: "Statician"
104                        ).save();
[139]105
[421]106                        // Create persons
107                        def person1 = new Person(
108                            lastName: "Scientist",
109                            firstName: "John",
110                            gender: "Male",
111                            initials: "J.R.",
112                            email: "john@scienceinstitute.com",
113                            phone: "1-555-3049",
114                            address: "First street 2,NYC"
115                        )
116                        .addToAffiliations( affiliation1 )
117                        .addToAffiliations( affiliation2 )
118                        .save();
[139]119
[421]120                        def person2 = new Person(
121                            lastName: "Statician",
122                            firstName: "Jane",
123                            gender: "Female",
124                            initials: "W.J.",
125                            email: "jane@statisticalcompany.de",
126                            phone: "49-555-8291",
127                            address: "Dritten strasse 38, Hamburg, Germany"
128                        )
129                        .addToAffiliations( affiliation2 )
130                        .save();
[232]131
[421]132                        // Create 30 persons to test pagination
133                        def personCounter = 1;
134                        30.times { new Person( firstName: "Person #${personCounter}", lastName: "Testperson", email: "email${personCounter++}@testdomain.com" ).save() }
[149]135
[453]136                        // Create a few publications
137                        println ".adding publications"
138                        def publication1 = new Publication(
139                            title: "Postnatal development of hypothalamic leptin receptors",
140                            authorsList: "Cottrell EC, Mercer JG, Ozanne SE.",
141                            pubMedID: "20472140",
142                            comments: "Not published yet",
143                            DOI: "unknown"
144                        )
145                        .save();
[235]146
[453]147                        def publication2 = new Publication(
148                            title: "Induction of regulatory T cells decreases adipose inflammation and alleviates insulin resistance in ob/ob mice",
149                            authorsList: "Ilan Y, Maron R, Tukpah AM, Maioli TU, Murugaiyan G, Yang K, Wu HY, Weiner HL.",
150                            pubMedID: "20445103",
151                            comments: "",
152                            DOI: ""
153                        )
154                        .save();
155
156            // Create templates
157
[224]158                        def genderField = new TemplateField(
[186]159                                name: 'Gender',type: TemplateFieldType.STRINGLIST,
[455]160                                listEntries: [new TemplateFieldListItem(name:'Male'),new TemplateFieldListItem(name: 'Female'),new TemplateFieldListItem(name: 'Unknown')])
[186]161                        .with { if (!validate()) { errors.each { println it} } else save()}
[253]162
[224]163                        def ageField = new TemplateField(
[455]164                                name: 'Age',type: TemplateFieldType.INTEGER,unit: 'years',comment: 'Either include age at the start of the study or date of birth (if known)')
[212]165                        .with { if (!validate()) { errors.each { println it} } else save()}
[186]166
[339]167                        def genotypeField = new TemplateField(
[461]168                                name: 'Genotype', type: TemplateFieldType.STRING,
[455]169                                comment: 'If present, indicate the genetic variance of the subject (the gene knock-out/in or transgene)')
[339]170                        .with { if (!validate()) { errors.each { println it} } else save()}
171
172                        def genotypeTypeField = new TemplateField(
173                                name: 'Genotype type',type: TemplateFieldType.STRINGLIST,
[375]174                                listEntries: [new TemplateFieldListItem(name:'wildtype'),
175                                        new TemplateFieldListItem(name:'transgenic'),
[339]176                                        new TemplateFieldListItem(name:'knock-out'),
[455]177                                        new TemplateFieldListItem(name:'knock-in')],
178                                comment: 'If a genotype was specified, please indicate here the type of the genotype') 
[339]179                        .with { if (!validate()) { errors.each { println it} } else save()}
180
181
[232]182                        // Nutritional study template
183
[364]184                        println ".adding academic study template..."
[232]185                        def studyTemplate = new Template(
[269]186                                name: 'Academic study', entity: dbnp.studycapturing.Study)
[455]187                                .addToFields(new TemplateField(name: 'Description',type: TemplateFieldType.TEXT,comment:'Describe here the type of subjects and the treatment, challenges and sampling.'))
188                                .addToFields(new TemplateField(
189                                        name: 'Study code',
190                                        type: TemplateFieldType.STRING,
191                                        preferredIdentifier:true,
192                                        comment: 'Fill out the code by which many people will recognize your study'))
193                                .addToFields(new TemplateField(name: 'Objectives',type: TemplateFieldType.TEXT,comment:'Fill out the aim or questions of the study'))
194                                .addToFields(new TemplateField(name: 'Consortium',type: TemplateFieldType.STRING,comment:'If the study was performed within a consortium (e.g. NMC, NuGO), you can indicate this here'))
195                                .addToFields(new TemplateField(name: 'Cohort name',type: TemplateFieldType.STRING,comment:'If a cohort was used the name or code of the cohort can be define here (define a cohort template)'))
196                                //.addToFields(new TemplateField(name: 'Time zone',type: TemplateFieldType.STRING,comment:'In the database the local time will be stored. This field is essential to be able to generalize time.'))
197                                .addToFields(new TemplateField(name: 'Responsible scientist',type: TemplateFieldType.STRING,comment:'Fill out the project leader of principle investigator of the study. (soon to be replaced with persons input)'))
198                                .addToFields(new TemplateField(name: 'Lab id',type: TemplateFieldType.STRING,comment:'In which lab was the study performed; indicate the roomnumber.'))
199                                .addToFields(new TemplateField(name: 'Institute',type: TemplateFieldType.STRING,comment:'In which institute was the study performed; indicate the full address information (to be replaced by persons-affiliations?)'))
[269]200                        .with { if (!validate()) { errors.each { println it} } else save()}
[232]201
[92]202                        // Mouse template
[364]203                        println ".adding mouse subject template..."
[92]204                        def mouseTemplate = new Template(
[269]205                                name: 'Mouse', entity: dbnp.studycapturing.Subject)
206                        .addToFields(new TemplateField(
[455]207                                name: 'Strain', type: TemplateFieldType.ONTOLOGYTERM, ontologies: [nciOntology], comment: "This is an ontology term, if the right strain is not in the list please add it with 'add more'"))
[339]208                        .addToFields(genotypeField)
209                        .addToFields(genotypeTypeField)
[224]210                        .addToFields(genderField)
211                        .addToFields(new TemplateField(
[455]212                                name: 'Age', type: TemplateFieldType.INTEGER, unit: 'weeks', comment: 'Age at start of study'))
[224]213                        .addToFields(new TemplateField(
[269]214                                name: 'Age type',type: TemplateFieldType.STRINGLIST,
215                                listEntries: [new TemplateFieldListItem(name:'postnatal'),new TemplateFieldListItem(name:'embryonal')]))
[224]216                        .addToFields(new TemplateField(
[455]217                                name: 'Cage',type: TemplateFieldType.STRING,comment:'Indicate the cage used for housing (type and/or size)'))
[269]218                        .addToFields(new TemplateField(
[455]219                                name: '#Mice in cage',type: TemplateFieldType.INTEGER,comment:'If known, indicate the number of mice per cage'))
[269]220                        .addToFields(new TemplateField(
[455]221                                name: 'Litter size',type: TemplateFieldType.INTEGER,comment:'If known, indicate the litter size of the litter from which the subject originates'))
[269]222                        .addToFields(new TemplateField(
[455]223                                name: 'Weight', type: TemplateFieldType.DOUBLE, unit: 'gram',comment:'If known indicate the weight of the subject in grams at the start of the study'))
[139]224                        .with { if (!validate()) { errors.each { println it} } else save()}
[97]225
[186]226                        // Human template
[364]227                        println ".adding human subject template..."
[186]228                        def humanTemplate = new Template(
[224]229                                name: 'Human', entity: dbnp.studycapturing.Subject)
230                        .addToFields(genderField)
231                        .addToFields(ageField)
232                        .addToFields(new TemplateField(
[455]233                                name: 'DOB',type: TemplateFieldType.DATE,comment:'Date of birth'))
[224]234                        .addToFields(new TemplateField(
[269]235                                name: 'Height',type: TemplateFieldType.DOUBLE, unit: 'm'))
[224]236                        .addToFields(new TemplateField(
[455]237                                name: 'Weight',type: TemplateFieldType.DOUBLE, unit: 'kg'))
[224]238                        .addToFields(new TemplateField(
[455]239                                name: 'BMI',type: TemplateFieldType.DOUBLE, unit: 'kg/m2',comment:'Body-mass-index'))
[269]240                        .addToFields(new TemplateField(
[455]241                                name: 'Race',type: TemplateFieldType.STRING,comment:'If known and of interest the ethnic group can be indicated'))
[269]242                        .addToFields(new TemplateField(
[455]243                                name: 'Waist circumference',type: TemplateFieldType.FLOAT, unit: 'cm',comment:'The waist circumference is measured just above the hip bone. Indicate the measure at the start of the study.'))
[269]244                        .addToFields(new TemplateField(
[455]245                                name: 'Hip circumference',type: TemplateFieldType.FLOAT, unit: 'cm',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.'))
[269]246                        .addToFields(new TemplateField(
[455]247                                name: 'Systolic blood pressure',type: TemplateFieldType.FLOAT, unit: 'mmHg',comment:'Indicate the levels at the start of the study in mmHG'))
[269]248                        .addToFields(new TemplateField(
[455]249                                name: 'Diastolic blood pressure',type: TemplateFieldType.FLOAT, unit: 'mmHg',comment:'Indicate the levels at the start of the study in mmHG'))
[269]250                        .addToFields(new TemplateField(
[455]251                                name: 'Heart rate',type: TemplateFieldType.FLOAT, unit: 'beats/min',comment:'Indicate the heart rate at the start of in study in beats per minute'))
[269]252                        .addToFields(new TemplateField(
[455]253                                name: 'Run-in-food',type: TemplateFieldType.TEXT,comment:'If defined, give a short description of the food used before the measurements'))
[186]254                        .with { if (!validate()) { errors.each { println it} } else save()}
[139]255
[269]256
[493]257                        def sampleRemarksField = new TemplateField(
258                                name: 'Remarks',type: TemplateFieldType.TEXT)
[339]259                        .with { if (!validate()) { errors.each { println it} } else save()}
260                        def sampleVialTextField = new TemplateField(
261                                name: 'Text on vial',type: TemplateFieldType.STRING)
262                        .with { if (!validate()) { errors.each { println it} } else save()}
263
[493]264                        // Human tissue sample template
[375]265                        println ".adding human sample template..."
[269]266                        def humanSampleTemplate = new Template(
267                                name: 'Human tissue sample', entity: dbnp.studycapturing.Sample)
[493]268                        .addToFields(sampleRemarksField)
[339]269                        .addToFields(sampleVialTextField)
[493]270            .addToFields(new TemplateField(
271                name: 'Sample measured weight',
272                unit: 'mg',
273                type: TemplateFieldType.FLOAT))
[339]274                        .with { if (!validate()) { errors.each { println it} } else save()}
275
[493]276            // Human blood sample template
277            println ".adding human sample template..."
278            def humanBloodSampleTemplate = new Template(
279                name: 'Human blood sample', entity: dbnp.studycapturing.Sample)
280            .addToFields(sampleRemarksField)
281            .addToFields(sampleVialTextField)
282            .addToFields(new TemplateField(
283                name: 'Sample measured volume',
284                unit: 'ml',
285                type: TemplateFieldType.FLOAT))
286            .with { if (!validate()) { errors.each { println it} } else save()}
287
[339]288                        //Plant template
[375]289                        println ".adding plant template..."
[339]290                        def plantTemplate = new Template(
291                                name: 'Plant template', entity: dbnp.studycapturing.Subject)
[269]292                        .addToFields(new TemplateField(
[339]293                                name: 'Variety', type: TemplateFieldType.STRING))
[269]294                        .addToFields(new TemplateField(
[339]295                                name: 'Ecotype', type: TemplateFieldType.STRING))
296                        .addToFields(genotypeField)
297                        .addToFields(genotypeTypeField)
[269]298                        .addToFields(new TemplateField(
[339]299                                name: 'Growth location', type: TemplateFieldType.STRINGLIST,
300                                listEntries: [new TemplateFieldListItem(name:'Greenhouse'),new TemplateFieldListItem(name: 'Field')]))
[269]301                        .addToFields(new TemplateField(
[339]302                                name: 'Room', type: TemplateFieldType.STRING,
303                                comment: 'Chamber number in case of Greenhouse'))
304                        .addToFields(new TemplateField(
305                                name: 'Position X', type: TemplateFieldType.FLOAT))
306                        .addToFields(new TemplateField(
307                                name: 'Position Y', type: TemplateFieldType.FLOAT))
308                        .addToFields(new TemplateField(
309                                name: 'Block', type: TemplateFieldType.STRING))
310                        .addToFields(new TemplateField(
311                                name: 'Temperature at day', type: TemplateFieldType.FLOAT))
312                        .addToFields(new TemplateField(
313                                name: 'Temperature at night', type: TemplateFieldType.FLOAT))
314                        .addToFields(new TemplateField(
315                                name: 'Photo period', type: TemplateFieldType.STRING))
316                        .addToFields(new TemplateField(
317                                name: 'Light intensity', type: TemplateFieldType.STRING))
318                        .addToFields(new TemplateField(
319                                name: 'Start date', type: TemplateFieldType.DATE))
320                        .addToFields(new TemplateField(
321                                name: 'Harvest date', type: TemplateFieldType.DATE))
322                        .addToFields(new TemplateField(
323                                name: 'Growth type', type: TemplateFieldType.STRINGLIST,
324                                listEntries: [new TemplateFieldListItem(name:'Standard'),new TemplateFieldListItem(name: 'Experimental')]))
325                        .addToFields(new TemplateField(
326                                name: 'Growth protocol', type: TemplateFieldType.TEXT))
327                        .addToFields(new TemplateField(
328                                name: 'Harvest delay', type: TemplateFieldType.TEXT))
[269]329                        .with { if (!validate()) { errors.each { println it} } else save()}
330
[375]331                        println ".adding plant sample template..."
[339]332                        def plantSampleTemplate = new Template(
333                                name: 'Plant sample', entity: dbnp.studycapturing.Sample)
[493]334                        .addToFields(sampleRemarksField)
[339]335                        .addToFields(sampleVialTextField)
336                        .with { if (!validate()) { errors.each { println it} } else save()}
337
[370]338                        def dietTreatmentTemplate = new Template(
[493]339                                name: 'Diet treatment HF45/LF10', entity: dbnp.studycapturing.Event)
[370]340                        .addToFields(new TemplateField(
[375]341                                name: 'Diet', type: TemplateFieldType.STRINGLIST,
342                                listEntries: [new TemplateFieldListItem(name:'10% fat (palm oil)'),new TemplateFieldListItem(name: '45% fat (palm oil)')]))
[370]343                        .with { if (!validate()) { errors.each { println it} } else save()}
344
345                        def boostTreatmentTemplate = new Template(
[493]346                                name: 'Leptin treatment', entity: dbnp.studycapturing.Event)
[370]347                        .addToFields(new TemplateField(
[493]348                                name: 'Compound', type: TemplateFieldType.STRINGLIST,
[375]349                                listEntries: [new TemplateFieldListItem(name:'Vehicle'),new TemplateFieldListItem(name: 'Leptin')]))
[370]350                        .with { if (!validate()) { errors.each { println it} } else save()}
351
[421]352                        def fastingTreatment = new Template(
[493]353                                name: 'Fasting treatment',
354                                description: 'Fasting Protocol NuGO PPSH',
355                                entity: dbnp.studycapturing.Event)
356                        .addToFields(new TemplateField(
357                                name: 'Fasting period',
358                                type: TemplateFieldType.STRING))
[421]359                         .with { if (!validate()) { errors.each { println it} } else save()}
[139]360
[421]361                        // SamplingEvent templates
[232]362
[493]363                        def samplingProtocolField = new TemplateField(
364                        name: 'SampleProtocol',type: TemplateFieldType.STRING)
365                        .with { if (!validate()) { errors.each { println it} } else save()}
366
[421]367                        def liverSamplingEventTemplate = new Template(
[186]368                                name: 'Liver extraction',
369                                description: 'Liver sampling for transcriptomics arrays',
[493]370                                entity: dbnp.studycapturing.SamplingEvent,
371                                sampleTemplates: [humanSampleTemplate])
372                        .addToFields(samplingProtocolField)
[421]373                        .addToFields(new TemplateField(
374                                name: 'Sample weight',
375                                unit: 'mg',
376                                type: TemplateFieldType.FLOAT))
377                        .with { if (!validate()) { errors.each { println it} } else save()}
[186]378
[421]379                        def bloodSamplingEventTemplate = new Template(
[186]380                                name: 'Blood extraction',
381                                description: 'Blood extraction targeted at lipid assays',
[493]382                                entity: dbnp.studycapturing.SamplingEvent,
383                                 sampleTemplates: [humanBloodSampleTemplate])
384                        .addToFields(samplingProtocolField)
[421]385                        .addToFields(new TemplateField(
386                                name: 'Sample volume',
387                                unit: 'ml',
388                                type: TemplateFieldType.FLOAT))
389                        .with { if (!validate()) { errors.each { println it} } else save()}
[186]390
391
[421]392                        // Add example studies
[406]393                        if (!(grails.util.GrailsUtil.environment == GrailsApplication.ENV_TEST)) {
394                                println ".adding NuGO PPS3 leptin example study..."
[421]395                                def mouseStudy = new Study(
[406]396                                        template: studyTemplate,
397                                        title:"NuGO PPS3 mouse study leptin module",
398                                        code:"PPS3_leptin_module",
399                                        researchQuestion:"Leptin etc.",
400                                        ecCode:"2007117.c",
[467]401                                        startDate: Date.parse('yyyy-MM-dd','2008-01-02')
[406]402                                )
403                                .with { if (!validate()) { errors.each { println it} } else save()}
[139]404
[464]405                                mouseStudy.setFieldValue('Description', "C57Bl/6 mice were fed a high fat (45 en%) or low fat (10 en%) diet after a four week run-in on low fat diet.");// After 1 week 10 mice that received a low fat diet were given an IP leptin challenge and 10 mice of the low-fat group received placebo injections. The same procedure was performed with mice that were fed the high-fat diet. After 4 weeks the procedure was repeated. In total 80 mice were culled." )
[421]406                                mouseStudy.save()
[375]407
[406]408                                def evLF = new Event(
[497]409                                        startTime: 3600,
410                                        endTime: 3600 +7 * 24 * 3600,
[406]411                                        template: dietTreatmentTemplate
412                                )
[421]413                                .setFieldValue( 'Diet','10% fat (palm oil)')
[406]414                                .with { if (!validate()) { errors.each { println it} } else save()}
[384]415
[406]416                                def evHF = new Event(
[497]417                                        startTime: 3600,
418                                        endTime: 3600 +7 * 24 * 3600,
[406]419                                        template: dietTreatmentTemplate
420                                )
421                                .setFieldValue( 'Diet','45% fat (palm oil)' )
422                                .with { if (!validate()) { errors.each { println it} } else save()}
[232]423
[406]424                                def evBV = new Event(
[497]425                                        startTime: 3600,
426                                        endTime: 3600 +7 * 24 * 3600,
[406]427                                        template: boostTreatmentTemplate
428                                )
429                                .setFieldValue( 'Compound','Vehicle' )
430                                .with { if (!validate()) { errors.each { println it} } else save()}
[232]431
[406]432                                def evBL = new Event(
[497]433                                        startTime: 3600,
434                                        endTime: 3600 +7 * 24 * 3600,
[406]435                                        template: boostTreatmentTemplate
436                                )
437                                .setFieldValue( 'Compound','Leptin' )
438                                .with { if (!validate()) { errors.each { println it} } else save()}
[232]439
[406]440                                def evLF4 = new Event(
[497]441                                        startTime: 3600,
442                                        endTime: 3600 + 4 * 7 * 24 * 3600,
[421]443                                        template: dietTreatmentTemplate
444                                )
445                                .setFieldValue( 'Diet','10% fat (palm oil)')
446                                .with { if (!validate()) { errors.each { println it} } else save()}
[232]447
[406]448                                def evHF4 = new Event(
[497]449                                        startTime: 3600,
450                                        endTime: 3600 + 4 * 7 * 24 * 3600,
[421]451                                        template: dietTreatmentTemplate
452                                )
453                                .setFieldValue( 'Diet','45% fat (palm oil)' )
454                                .with { if (!validate()) { errors.each { println it} } else save()}
[232]455
[406]456                                def evBV4 = new Event(
[497]457                                        startTime: 3600,
458                                        endTime: 3600 + 4 * 7 * 24 * 3600,
[421]459                                        template: boostTreatmentTemplate
460                                )
461                                .setFieldValue( 'Compound','Vehicle' )
462                                .with { if (!validate()) { errors.each { println it} } else save()}
[232]463
[406]464                                def evBL4 = new Event(
[497]465                                        startTime: 3600,
466                                        endTime: 3600 + 4 * 7 * 24 * 3600,
[421]467                                        template: boostTreatmentTemplate
468                                )
469                                .setFieldValue( 'Compound','Leptin' )
470                                .with { if (!validate()) { errors.each { println it} } else save()}
[232]471
[406]472                                def evS = new SamplingEvent(
[497]473                                        startTime: 3600 +7 * 24 * 3600,
474                                        endTime: 3600 +7 * 24 * 3600,
[421]475                                        template: liverSamplingEventTemplate)
476                                .setFieldValue('Sample weight',5F)
477                                .with { if (!validate()) { errors.each { println it} } else save()}
[232]478
[406]479                                def evS4 = new SamplingEvent(
[497]480                                        startTime: 3600 +7 * 24 * 3600,
481                                        endTime: 3600 +7 * 24 * 3600,
[421]482                                        template: liverSamplingEventTemplate)
483                                .setFieldValue('Sample weight',5F)
484                                .with { if (!validate()) { errors.each { println it} } else save()}
[232]485
[406]486                                // Add events to study
[421]487                                mouseStudy
[406]488                                .addToEvents(evLF)
489                                .addToEvents(evHF)
490                                .addToEvents(evBV)
491                                .addToEvents(evBL)
492                                .addToEvents(evLF4)
493                                .addToEvents(evHF4)
494                                .addToEvents(evBV4)
495                                .addToEvents(evBL4)
496                                .addToSamplingEvents(evS)
497                                .addToSamplingEvents(evS4)
498                                .save()
[232]499
[406]500                                def LFBV1 = new EventGroup(name:"10% fat + vehicle for 1 week")
501                                .addToEvents(evLF)
502                                .addToEvents(evBV)
[421]503                                .addToEvents(evS)
[406]504                                .with { if (!validate()) { errors.each { println it} } else save()}
[232]505
[406]506                                def LFBL1 = new EventGroup(name:"10% fat + leptin for 1 week")
507                                .addToEvents(evLF)
508                                .addToEvents(evBL)
[421]509                                .addToEvents(evS)
[406]510                                .with { if (!validate()) { errors.each { println it} } else save()}
[232]511
[406]512                                def HFBV1 = new EventGroup(name:"45% fat + vehicle for 1 week")
513                                .addToEvents(evHF)
514                                .addToEvents(evBV)
[421]515                                .addToEvents(evS)
[406]516                                .with { if (!validate()) { errors.each { println it} } else save()}
[232]517
[406]518                                def HFBL1 = new EventGroup(name:"45% fat + leptin for 1 week")
519                                .addToEvents(evHF)
520                                .addToEvents(evBL)
[421]521                                .addToEvents(evS)
[406]522                                .with { if (!validate()) { errors.each { println it} } else save()}
[232]523
[406]524                                def LFBV4 = new EventGroup(name:"10% fat + vehicle for 4 weeks")
525                                .addToEvents(evLF4)
526                                .addToEvents(evBV4)
[421]527                                .addToEvents(evS4)
[406]528                                .with { if (!validate()) { errors.each { println it} } else save()}
[232]529
[406]530                                def LFBL4 = new EventGroup(name:"10% fat + leptin for 4 weeks")
531                                .addToEvents(evLF4)
532                                .addToEvents(evBL4)
[421]533                                .addToEvents(evS4)
[406]534                                .with { if (!validate()) { errors.each { println it} } else save()}
[232]535
[406]536                                def HFBV4 = new EventGroup(name:"45% fat + vehicle for 4 weeks")
537                                .addToEvents(evHF4)
538                                .addToEvents(evBV4)
[421]539                                .addToEvents(evS4)
[406]540                                .with { if (!validate()) { errors.each { println it} } else save()}
[232]541
[406]542                                def HFBL4 = new EventGroup(name:"45% fat + leptin for 4 weeks")
543                                .addToEvents(evHF4)
544                                .addToEvents(evBL4)
[421]545                                .addToEvents(evS4)
[406]546                                .with { if (!validate()) { errors.each { println it} } else save()}
[232]547
[493]548                // Add subjects and samples and compose EventGroups
[406]549                                def x=1
[442]550                                20.times {
[406]551                                        def currentSubject = new Subject(
552                                                name: "A" + x++,
553                                                species: mouseTerm,
554                                                template: mouseTemplate,
555                                        )
556                                        .setFieldValue("Gender", "Male")
[421]557                                        .setFieldValue("Genotype", c57bl6Term)
[455]558                                        .setFieldValue("Age", 17)
[406]559                                        .setFieldValue("Cage", "" + (int)(x/2))
560                                        .with { if (!validate()) { errors.each { println it} } else save(flush:true)}
[136]561
[421]562                                        mouseStudy.addToSubjects(currentSubject)
[406]563                                        .with { if (!validate()) { errors.each { println it} } else save()}
[232]564
[406]565                                        // Add subject to appropriate EventGroup
566                                        if (x > 70) { HFBL4.addToSubjects(currentSubject).save() }
567                                        else if (x > 60) { HFBV4.addToSubjects(currentSubject).save() }
568                                        else if (x > 50) { LFBL4.addToSubjects(currentSubject).save() }
569                                        else if (x > 40) { LFBV4.addToSubjects(currentSubject).save() }
570                                        else if (x > 30) { HFBL1.addToSubjects(currentSubject).save() }
571                                        else if (x > 20) { HFBV1.addToSubjects(currentSubject).save() }
572                                        else if (x > 10) { LFBL1.addToSubjects(currentSubject).save() }
573                                        else             { LFBV1.addToSubjects(currentSubject).save() }
[232]574
[406]575                                }
[370]576
[406]577                                // Add EventGroups to study
[421]578                                mouseStudy
[406]579                                .addToEventGroups(LFBV1)
580                                .addToEventGroups(LFBL1)
581                                .addToEventGroups(HFBV1)
582                                .addToEventGroups(HFBL1)
[421]583                                .addToEventGroups(LFBV4)
584                                .addToEventGroups(LFBL4)
585                                .addToEventGroups(HFBV4)
586                                .addToEventGroups(HFBL4)
[236]587
[453]588                                // Add persons and publications to study
[406]589                                def studyperson1 = new StudyPerson( person: person1, role: role1 ).save();
590                                def studyperson2 = new StudyPerson( person: person2, role: role2 ).save();
[211]591
[421]592                                mouseStudy
[406]593                                .addToPersons( studyperson1 )
594                                .addToPersons( studyperson2 )
[453]595                                .addToPublications( publication1 )
596                                .addToPublications( publication2 )
[406]597                                .save()
[370]598
[421]599                                println ".adding NuGO PPSH example study..."
[148]600
[406]601                                def humanStudy = new Study(
602                                        template: studyTemplate,
603                                        title:"NuGO PPS human study",
604                                        code:"PPSH",
605                                        researchQuestion:"How much are fasting plasma and urine metabolite levels affected by prolonged fasting ?",
606                                        description:"Human study",
607                                        ecCode:"unknown",
[421]608                                        startDate: Date.parse('yyyy-MM-dd','2008-01-14'))
609                                .setFieldValue( 'Description', "Human study performed at RRI; centres involved: RRI, IFR, TUM, Maastricht U." )
610                                .with { if (!validate()) { errors.each { println it} } else save()}
[232]611
[421]612                                def rootGroup = new EventGroup(name: 'Root group');
613
[406]614                                def fastingEvent = new Event(
[497]615                                        startTime: 3 * 24 * 3600 + 22 * 3600,
616                                        endTime: 3 * 24 * 3600 + 30 * 3600,
[421]617                                        template: fastingTreatment)
618                                .setFieldValue('Fasting period','8h');
[232]619
[421]620
[406]621                                def bloodSamplingEvent = new SamplingEvent(
[497]622                                        startTime: 3 * 24 * 3600 + 30 * 3600,
623                                        endTime: 3 * 24 * 3600 + 30 * 3600,
[421]624                                        template: bloodSamplingEventTemplate)
625                                .setFieldValue('Sample volume',4.5F);
[148]626
[406]627                                rootGroup.addToEvents fastingEvent
628                                rootGroup.addToEvents bloodSamplingEvent
629                                rootGroup.save()
[232]630
[421]631                                def y = 1
632                                11.times {
633                                        def currentSubject = new Subject(
634                                              name: "" + y++,
635                                              species: humanTerm,
636                                              template: humanTemplate)
[424]637                                        .setFieldValue("Gender", (Math.random() > 0.5) ? "Male" : "Female")
[421]638                                        .setFieldValue("DOB", new java.text.SimpleDateFormat("dd-mm-yy").parse("01-02-19" + (10 + (int) (Math.random() * 80))))
[455]639                                        .setFieldValue("Age", 30)
[421]640                                        .setFieldValue("Height", Math.random() * 2F)
[455]641                                        .setFieldValue("Weight", Math.random() * 150F)
[421]642                                        .setFieldValue("BMI", 20 + Math.random() * 10F)
643                                        .with { if (!validate()) { errors.each { println it} } else save()}
[232]644
[421]645                                        rootGroup.addToSubjects currentSubject
646                                        rootGroup.save()
[148]647
[421]648                                        def currentSample = new Sample(
649                                              name: currentSubject.name + '_B',
650                                              material: bloodTerm,
651                                              parentSubject: currentSubject,
[493]652                                              parentEvent: bloodSamplingEvent,
653                          template: humanBloodSampleTemplate);
[389]654
[421]655                                        humanStudy.addToSubjects(currentSubject).addToSamples(currentSample).with { if (!validate()) { errors.each { println it} } else save()}
656                                }
[389]657
[421]658                                humanStudy.addToEvents(fastingEvent)
659                                humanStudy.addToSamplingEvents(bloodSamplingEvent)
660                                humanStudy.addToEventGroups rootGroup
[186]661
[453]662
663                                // Add persons to study
664                                def studyperson3 = new StudyPerson( person: person1, role: role2 ).save();
665
666                                humanStudy
667                                .addToPersons( studyperson3 )
668                                .addToPublications( publication2 )
669                                .save()
670
[421]671                                /*
[406]672                                // Add clinical data
[186]673
[406]674                                def lipidAssay = new dbnp.clinicaldata.ClinicalAssay(
675                                        name: 'Lipid profile',
676                                        approved: true
677                                ).with { if (!validate()) { errors.each { println it} } else save()}
[186]678
[406]679                                def ldlMeasurement = new dbnp.clinicaldata.ClinicalMeasurement(
680                                        name: 'LDL',
681                                        unit: 'mg/dL',
682                                        type: dbnp.data.FeatureType.QUANTITATIVE,
683                                        referenceValues: '100 mg/dL',
684                                        detectableLimit: 250,
685                                        isDrug: false, isIntake: true, inSerum: true
686                                ).with { if (!validate()) { errors.each { println it} } else save()}
[389]687
[406]688                                def hdlMeasurement = new dbnp.clinicaldata.ClinicalMeasurement(
689                                        name: 'HDL',
690                                        unit: 'mg/dL',
691                                        type: dbnp.data.FeatureType.QUANTITATIVE,
692                                        referenceValues: '50 mg/dL',
693                                        detectableLimit: 100,
694                                        isDrug: false, isIntake: true, inSerum: true
695                                ).with { if (!validate()) { errors.each { println it} } else save()}
[186]696
[406]697                                lipidAssay.addToMeasurements ldlMeasurement
698                                lipidAssay.addToMeasurements hdlMeasurement
699
700                                def lipidAssayInstance = new dbnp.clinicaldata.ClinicalAssayInstance(
701                                        assay: lipidAssay
[186]702                                ).with { if (!validate()) { errors.each { println it} } else save()}
703
[406]704                                humanStudy.samples*.each {
705                                        new dbnp.clinicaldata.ClinicalFloatData(
706                                                assay: lipidAssayInstance,
707                                                measurement: ldlMeasurement,
708                                                sample: it.name,
709                                                value: Math.round(Math.random()*ldlMeasurement.detectableLimit)
710                                        ).with { if (!validate()) { errors.each { println it} } else save()}
711
712                                        new dbnp.clinicaldata.ClinicalFloatData(
713                                                assay: lipidAssayInstance,
714                                                measurement: hdlMeasurement,
715                                                sample: it.name,
716                                                value: Math.round(Math.random()*hdlMeasurement.detectableLimit)
717                                        ).with { if (!validate()) { errors.each { println it} } else save()}
718                                }
[442]719                                */
[406]720                                // Add assay to study capture module
721
722                                def clinicalModule = new AssayModule(
723                                        name: 'Clinical data',
724                                        type: AssayType.CLINICAL_DATA,
725                                        platform: 'clinical measurements',
726                                        url: 'http://localhost:8080/gscf'
[186]727                                ).with { if (!validate()) { errors.each { println it} } else save()}
728
[406]729                                def lipidAssayRef = new Assay(
730                                        name: 'Lipid profiling',
731                                        module: clinicalModule,
[442]732                                        externalAssayId: 0
[406]733                                ).with { if (!validate()) { errors.each { println it} } else save()}
[389]734
[406]735                                humanStudy.samples*.each {
736                                        lipidAssayRef.addToSamples(it)
737                                }
738                                lipidAssayRef.save()
[186]739
[406]740                                humanStudy.addToAssays(lipidAssayRef);
741                                humanStudy.save()
[453]742
743                                mouseStudy.addToAssays(lipidAssayRef);
744                                mouseStudy.save()
745
[186]746                        }
747                }
[458]748
749                // Ontologies must be connected to the templatefields in runtime
750                // because the Ontology.findByNcboId is not available otherwise
751                TemplateEntity.getField( Subject.domainFields, 'species' ).ontologies = [Ontology.findByNcboId(1132)]
752                TemplateEntity.getField( Sample.domainFields, 'material' ).ontologies = [Ontology.findByNcboId(1005)]
753
[92]754        }
755
756        def destroy = {
757        }
[366]758} 
Note: See TracBrowser for help on using the repository browser.