root/trunk/grails-app/conf/BootStrap.groovy @ 392

Revision 392, 32.4 KB (checked in by keesvb, 4 years ago)

switched back from the fancy 'integrate domain fields as system fields directly into the Template object at the time of creation' method to the plain 'implement getFieldValue, setFieldValue and giveFields to work for both domain and template fields'. NB: this might affect Events, since until now startTime and endTime were moved directly into template! Switch any Event.template.fields to Event.giveFields()

  • Property svn:keywords set to Author Rev Date
Line 
1import dbnp.studycapturing.*
2
3import dbnp.data.Ontology
4import dbnp.data.Term
5
6/**
7 * Application Bootstrapper
8 * @Author Jeroen Wesbeek
9 * @Since 20091021
10 *
11 * Revision information:
12 * $Rev$
13 * $Author$
14 * $Date$
15 */
16class BootStrap {
17        def init = {servletContext ->
18                // define timezone
19                System.setProperty('user.timezone', 'CET')
20
21                // we could also check if we are in development by GrailsUtil.environment == GrailsApplication.ENV_DEVELOPMENT
22                if (Study.count() == 0) {
23                        println ".development bootstrapping...";
24
25                        // add NCBI species ontology
26                        println ".adding NCBI species ontology"
27                        def speciesOntology = new Ontology(
28                                name: 'NCBI organismal classification',
29                                description: 'A taxonomic classification of living organisms and associated artifacts for their controlled description within the context of databases.',
30                                url: 'http://www.ncbi.nlm.nih.gov/Taxonomy/taxonomyhome.html/',
31                                versionNumber: '1.2',
32                                ncboId: '1132',
33                                ncboVersionedId: '38802'
34                        ).with { if (!validate()) { errors.each { println it} } else save()}
35
36                        // add TERMS
37                        println ".adding mouse term"
38                        def mouseTerm = new Term(
39                                name: 'Mus musculus',
40                                ontology: speciesOntology,
41                                accession: '10090'
42                        ).with { if (!validate()) { errors.each { println it} } else save()}
43                        println ".adding human term"
44                        def humanTerm = new Term(
45                                name: 'Homo sapiens',
46                                ontology: speciesOntology,
47                                accession: '9606'
48                        ).with { if (!validate()) { errors.each { println it} } else save()}
49
50                        // Create a few persons, roles and Affiliations
51                        println ".adding persons, roles and affiliations"
52                        def affiliation1 = new PersonAffiliation(
53                            name: "Science Institute NYC"
54                        ).save();
55                        def affiliation2 = new PersonAffiliation(
56                            name: "InfoStats GmbH, Hamburg"
57                        ).save();
58                        def role1 = new PersonRole(
59                            name: "Principal Investigator"
60                        ).save();
61                        def role2 = new PersonRole(
62                            name: "Statician"
63                        ).save();
64
65                        // Create 30 roles to test pagination
66                        def roleCounter = 1;
67                        30.times { new PersonRole( name: "Rol #${roleCounter++}" ).save() }
68
69                        // Create persons
70                        def person1 = new Person(
71                            lastName: "Scientist",
72                            firstName: "John",
73                            gender: "Male",
74                            initials: "J.R.",
75                            email: "john@scienceinstitute.com",
76                            phone: "1-555-3049",
77                            address: "First street 2,NYC"
78                        )
79                        .addToAffiliations( affiliation1 )
80                        .addToAffiliations( affiliation2 )
81                        .save();
82                       
83                        def person2 = new Person(
84                            lastName: "Statician",
85                            firstName: "Jane",
86                            gender: "Female",
87                            initials: "W.J.",
88                            email: "jane@statisticalcompany.de",
89                            phone: "49-555-8291",
90                            address: "Dritten strasse 38, Hamburg, Germany"
91                        )
92                        .addToAffiliations( affiliation2 )
93                        .save();
94
95                        // Create 30 persons to test pagination
96                        def personCounter = 1;
97                        30.times { new Person( firstName: "Person #${personCounter}", lastName: "Testperson", email: "email${personCounter++}@testdomain.com" ).save() }
98
99 /*   COMMENTED OUT BECAUSE IT BREAKS EVERYTHING AFTER REFACTORING THE DATAMODEL
100
101                        // ontologies
102                        def speciesOntology = new Ontology(
103                                name: 'NCBI Taxonomy',
104                                shortName: 'Taxon',
105                                url: 'http://www.obofoundry.org/cgi-bin/detail.cgi?id=ncbi_taxonomy'
106                        ).with { if (!validate()) { errors.each { println it} } else save()}
107
108                        def humanBodyOntology = new Ontology(
109                                name: 'Foundational Model of Anatomy',
110                                shortName: 'HumanBody',
111                                url: 'http://bioportal.bioontology.org/ontologies/39966'
112                        ).with { if (!validate()) { errors.each { println it} } else save()}
113
114                        def nciOntology = new Ontology(
115                                name: 'NCI Thesaurus',
116                                shortName: 'NCI',
117                                url: 'http://bioportal.bioontology.org/ontologies/42331'
118                        ).with { if (!validate()) { errors.each { println it} } else save()}
119
120                        // terms
121                        def mouseTerm = new Term(
122                                name: 'Mus musculus',
123                                ontology: speciesOntology,
124                                accession: '10090'
125                        ).with { if (!validate()) { errors.each { println it} } else save()}
126                        def humanTerm = new Term(
127                                name: 'Homo sapiens',
128                                ontology: speciesOntology,
129                                accession: '9606'
130                        ).with { if (!validate()) { errors.each { println it} } else save()}
131                        def arabTerm = new Term(
132                                name: 'Arabidopsis thaliana',
133                                ontology: speciesOntology,
134                                accession: '3702'
135                        ).with { if (!validate()) { errors.each { println it} } else save()}
136                       
137                        def bloodTerm = new Term(
138                                name: 'Portion of blood',
139                                ontology: humanBodyOntology,
140                                accession: '9670'
141                        ).with { if (!validate()) { errors.each { println it} } else save()}
142
143                        def c57bl6Term = new Term(
144                                name: 'C57BL/6 Mouse',
145                                ontology: nciOntology,
146                                accession: 'C14424'
147                        ).with { if (!validate()) { errors.each { println it} } else save()}
148
149                        def madmaxOntology = new Ontology(
150                                name: 'Madmax ontology',
151                                shortName: 'MDMX',
152                                url: 'madmax.bioinformatics.nl'
153                        ).with { if (!validate()) { errors.each { println it} } else save()}
154
155                        def treatmentTerm = new Term(
156                                name: 'ExperimentalProtocol',
157                                ontology: madmaxOntology,
158                                accession: 'P-MDMXGE-264'
159                        ).with { if (!validate()) { errors.each { println it} } else save()}
160
161                        def dietProtocol = new Protocol(
162                                name: 'Diet treatment Protocol NuGO PPS3 leptin module',
163                                reference: treatmentTerm
164                        ).with { if (!validate()) { errors.each { println it} } else save()}
165
166                        def boostProtocol = new Protocol(
167                                name: 'Boost treatment Protocol NuGO PPS3 leptin module',
168                                reference: treatmentTerm
169                        ).with { if (!validate()) { errors.each { println it} } else save()}
170
171                        def fastingProtocol = new Protocol(
172                                name: 'Fasting',
173                                reference: treatmentTerm
174                        ).with { if (!validate()) { errors.each { println it} } else save()}
175
176
177                        // ParameterStringListItems
178                        def oil10= new ParameterStringListItem(
179                                name: '10% fat (palm oil)'
180                        ).with { if (!validate()) { errors.each { println it} } else save()}
181                        def oil45= new ParameterStringListItem(
182                                name: '45% fat (palm oil)'
183                        ).with { if (!validate()) { errors.each { println it} } else save()}
184                        def vehicle= new ParameterStringListItem(
185                                name: 'Vehicle'
186                        ).with { if (!validate()) { errors.each { println it} } else save()}
187                        def leptin= new ParameterStringListItem(
188                                name: 'Leptin'
189                        ).with { if (!validate()) { errors.each { println it} } else save()}
190
191
192                        dietProtocol
193                        .addToParameters(new ProtocolParameter(
194                                name: 'Diet',
195                                type: ProtocolParameterType.STRINGLIST,
196                                listEntries: [oil10,oil45]))
197                        .save()
198
199                        boostProtocol
200                        .addToParameters(new ProtocolParameter(
201                                name: 'Compound',
202                                type: ProtocolParameterType.STRINGLIST,
203                                listEntries: [vehicle,leptin]))
204                        .save()
205
206                        fastingProtocol
207                        .addToParameters(new ProtocolParameter(
208                                name: 'Fasting period',
209                                type: ProtocolParameterType.STRING))
210                        .save()
211
212
213                        // sampling event protocols
214
215                        def liverSamplingProtocol = new Protocol(
216                                name: 'Liver sampling'
217                        ).with { if (!validate()) { errors.each { println it} } else save()}
218
219                        liverSamplingProtocol
220                        .addToParameters(new ProtocolParameter(
221                                name: 'Sample weight',
222                                unit: 'mg',
223                                type: ProtocolParameterType.FLOAT))
224                        .save()
225
226                        def bloodSamplingProtocol = new Protocol(
227                                name: 'Blood sampling'
228                        ).with { if (!validate()) { errors.each { println it} } else save()}
229
230                        bloodSamplingProtocol
231                        .addToParameters(new ProtocolParameter(
232                                name: 'Sample volume',
233                                unit: 'ml',
234                                type: ProtocolParameterType.FLOAT))
235                        .save()
236 */
237                        // create system user
238
239                        /*def systemUser = userService.createUser(InstanceGenerator.user(
240                                username: 'system',
241                                pass: 'system',
242                                passConfirm: 'system',
243                                enabled: true
244                        ))*/
245
246 
247                        def genderField = new TemplateField(
248                                name: 'Gender',type: TemplateFieldType.STRINGLIST,
249                                listEntries: [new TemplateFieldListItem(name:'Male'),new TemplateFieldListItem(name: 'Female')])
250                        .with { if (!validate()) { errors.each { println it} } else save()}
251
252                        def ageField = new TemplateField(
253                                name: 'Age (years)',type: TemplateFieldType.INTEGER,unit: 'years')
254                        .with { if (!validate()) { errors.each { println it} } else save()}
255
256                        def genotypeField = new TemplateField(
257                                name: 'Genotype', type: TemplateFieldType.ONTOLOGYTERM)
258                        .with { if (!validate()) { errors.each { println it} } else save()}
259
260                        def genotypeTypeField = new TemplateField(
261                                name: 'Genotype type',type: TemplateFieldType.STRINGLIST,
262                                listEntries: [new TemplateFieldListItem(name:'wildtype'),
263                                        new TemplateFieldListItem(name:'transgenic'),
264                                        new TemplateFieldListItem(name:'knock-out'),
265                                        new TemplateFieldListItem(name:'knock-in')])
266                        .with { if (!validate()) { errors.each { println it} } else save()}
267
268
269                        // Nutritional study template
270
271                        println ".adding academic study template..."
272                        def studyTemplate = new Template(
273                                name: 'Academic study', entity: dbnp.studycapturing.Study)
274                                .addToFields(new TemplateField(name: 'Description',type: TemplateFieldType.TEXT))
275                                .addToFields(new TemplateField(name: 'Study code',type: TemplateFieldType.STRING))
276                                .addToFields(new TemplateField(name: 'Objectives',type: TemplateFieldType.TEXT))
277                                .addToFields(new TemplateField(name: 'Consortium',type: TemplateFieldType.STRING))
278                                .addToFields(new TemplateField(name: 'Cohort name',type: TemplateFieldType.STRING))
279                                .addToFields(new TemplateField(name: 'Time zone',type: TemplateFieldType.STRING))
280                                .addToFields(new TemplateField(name: 'Responsible scientist',type: TemplateFieldType.STRING))
281                                .addToFields(new TemplateField(name: 'Lab id',type: TemplateFieldType.STRING))
282                                .addToFields(new TemplateField(name: 'Institute',type: TemplateFieldType.STRING))
283                        .with { if (!validate()) { errors.each { println it} } else save()}
284
285                        // Mouse template
286                        println ".adding mouse subject template..."
287                        def mouseTemplate = new Template(
288                                name: 'Mouse', entity: dbnp.studycapturing.Subject)
289                        .addToFields(new TemplateField(
290                                name: 'Strain', type: TemplateFieldType.ONTOLOGYTERM))
291                        .addToFields(genotypeField)
292                        .addToFields(genotypeTypeField)
293                        .addToFields(genderField)
294                        .addToFields(new TemplateField(
295                                name: 'Age (weeks)', type: TemplateFieldType.INTEGER, unit: 'weeks'))
296                        .addToFields(new TemplateField(
297                                name: 'Age type',type: TemplateFieldType.STRINGLIST,
298                                listEntries: [new TemplateFieldListItem(name:'postnatal'),new TemplateFieldListItem(name:'embryonal')]))
299                        .addToFields(new TemplateField(
300                                name: 'Cage',type: TemplateFieldType.STRING))
301                        .addToFields(new TemplateField(
302                                name: '#Mice in cage',type: TemplateFieldType.INTEGER))
303                        .addToFields(new TemplateField(
304                                name: 'Litter size',type: TemplateFieldType.INTEGER))
305                        .addToFields(new TemplateField(
306                                name: 'Weight (g)', type: TemplateFieldType.DOUBLE, unit: 'gram'))
307                        .with { if (!validate()) { errors.each { println it} } else save()}
308
309                        // Human template
310                        println ".adding human subject template..."
311                        def humanTemplate = new Template(
312                                name: 'Human', entity: dbnp.studycapturing.Subject)
313                        .addToFields(genderField)
314                        .addToFields(ageField)
315                        .addToFields(new TemplateField(
316                                name: 'DOB',type: TemplateFieldType.DATE))
317                        .addToFields(new TemplateField(
318                                name: 'Height',type: TemplateFieldType.DOUBLE, unit: 'm'))
319                        .addToFields(new TemplateField(
320                                name: 'Weight (kg)',type: TemplateFieldType.DOUBLE, unit: 'kg'))
321                        .addToFields(new TemplateField(
322                                name: 'BMI',type: TemplateFieldType.DOUBLE, unit: 'kg/m2'))
323                        .addToFields(new TemplateField(
324                                name: 'Race',type: TemplateFieldType.STRING))
325                        .addToFields(new TemplateField(
326                                name: 'Waist circumference',type: TemplateFieldType.FLOAT, unit: 'cm'))
327                        .addToFields(new TemplateField(
328                                name: 'Hip circumference',type: TemplateFieldType.FLOAT, unit: 'cm'))
329                        .addToFields(new TemplateField(
330                                name: 'Systolic blood pressure',type: TemplateFieldType.FLOAT, unit: 'mmHg'))
331                        .addToFields(new TemplateField(
332                                name: 'Diastolic blood pressure',type: TemplateFieldType.FLOAT, unit: 'mmHg'))
333                        .addToFields(new TemplateField(
334                                name: 'Heart rate',type: TemplateFieldType.FLOAT, unit: 'beats/min'))
335                        .addToFields(new TemplateField(
336                                name: 'Run-in-food',type: TemplateFieldType.TEXT))
337                        .with { if (!validate()) { errors.each { println it} } else save()}
338
339
340                        def sampleDescriptionField = new TemplateField(
341                                name: 'Description',type: TemplateFieldType.TEXT)
342                        .with { if (!validate()) { errors.each { println it} } else save()}
343                        def sampleTypeField = new TemplateField(
344                                name: 'SampleType',type: TemplateFieldType.STRING)
345                        .with { if (!validate()) { errors.each { println it} } else save()}
346                        def sampleProtocolField = new TemplateField(
347                                name: 'SampleProtocol',type: TemplateFieldType.STRING)
348                        .with { if (!validate()) { errors.each { println it} } else save()}
349                        def sampleVialTextField = new TemplateField(
350                                name: 'Text on vial',type: TemplateFieldType.STRING)
351                        .with { if (!validate()) { errors.each { println it} } else save()}
352
353                        // Human sample template
354                        println ".adding human sample template..."
355                        def humanSampleTemplate = new Template(
356                                name: 'Human tissue sample', entity: dbnp.studycapturing.Sample)
357                        .addToFields(sampleDescriptionField)
358                        .addToFields(sampleTypeField)
359                        .addToFields(sampleProtocolField)
360                        .addToFields(sampleVialTextField)
361                        .with { if (!validate()) { errors.each { println it} } else save()}
362
363                        //Plant template
364                        println ".adding plant template..."
365                        def plantTemplate = new Template(
366                                name: 'Plant template', entity: dbnp.studycapturing.Subject)
367                        .addToFields(new TemplateField(
368                                name: 'Variety', type: TemplateFieldType.STRING))
369                        .addToFields(new TemplateField(
370                                name: 'Ecotype', type: TemplateFieldType.STRING))
371                        .addToFields(genotypeField)
372                        .addToFields(genotypeTypeField)
373                        .addToFields(new TemplateField(
374                                name: 'Growth location', type: TemplateFieldType.STRINGLIST,
375                                listEntries: [new TemplateFieldListItem(name:'Greenhouse'),new TemplateFieldListItem(name: 'Field')]))
376                        .addToFields(new TemplateField(
377                                name: 'Room', type: TemplateFieldType.STRING,
378                                comment: 'Chamber number in case of Greenhouse'))
379                        .addToFields(new TemplateField(
380                                name: 'Position X', type: TemplateFieldType.FLOAT))
381                        .addToFields(new TemplateField(
382                                name: 'Position Y', type: TemplateFieldType.FLOAT))
383                        .addToFields(new TemplateField(
384                                name: 'Block', type: TemplateFieldType.STRING))
385                        .addToFields(new TemplateField(
386                                name: 'Temperature at day', type: TemplateFieldType.FLOAT))
387                        .addToFields(new TemplateField(
388                                name: 'Temperature at night', type: TemplateFieldType.FLOAT))
389                        .addToFields(new TemplateField(
390                                name: 'Photo period', type: TemplateFieldType.STRING))
391                        .addToFields(new TemplateField(
392                                name: 'Light intensity', type: TemplateFieldType.STRING))
393                        .addToFields(new TemplateField(
394                                name: 'Start date', type: TemplateFieldType.DATE))
395                        .addToFields(new TemplateField(
396                                name: 'Harvest date', type: TemplateFieldType.DATE))
397                        .addToFields(new TemplateField(
398                                name: 'Growth type', type: TemplateFieldType.STRINGLIST,
399                                listEntries: [new TemplateFieldListItem(name:'Standard'),new TemplateFieldListItem(name: 'Experimental')]))
400                        .addToFields(new TemplateField(
401                                name: 'Growth protocol', type: TemplateFieldType.TEXT))
402                        .addToFields(new TemplateField(
403                                name: 'Harvest delay', type: TemplateFieldType.TEXT))
404                        .with { if (!validate()) { errors.each { println it} } else save()}
405
406                        println ".adding plant sample template..."
407                        def plantSampleTemplate = new Template(
408                                name: 'Plant sample', entity: dbnp.studycapturing.Sample)
409                        .addToFields(sampleDescriptionField)
410                        .addToFields(sampleTypeField)
411                        .addToFields(sampleProtocolField)
412                        .addToFields(sampleVialTextField)
413                        .with { if (!validate()) { errors.each { println it} } else save()}
414
415
416                        // Event templates
417                        def dietTreatmentTemplate = new Template(
418                                name: 'Diet treatment', entity: dbnp.studycapturing.Event)
419                        .addToFields(sampleDescriptionField)
420                        .addToFields(new TemplateField(
421                                name: 'Diet', type: TemplateFieldType.STRINGLIST,
422                                listEntries: [new TemplateFieldListItem(name:'10% fat (palm oil)'),new TemplateFieldListItem(name: '45% fat (palm oil)')]))
423                        .with { if (!validate()) { errors.each { println it} } else save()}
424
425                        def boostTreatmentTemplate = new Template(
426                                name: 'Boost treatment', entity: dbnp.studycapturing.Event)
427                        .addToFields(sampleDescriptionField)
428                        .addToFields(new TemplateField(
429                                name: 'Compound', type: TemplateFieldType.STRING,
430                                listEntries: [new TemplateFieldListItem(name:'Vehicle'),new TemplateFieldListItem(name: 'Leptin')]))
431                        .with { if (!validate()) { errors.each { println it} } else save()}
432
433                        /*
434                        //events
435                        def eventDiet = new EventDescription(
436                                name: 'Diet treatment',
437                                description: 'Diet treatment (fat percentage)',
438                                classification: treatmentTerm,
439                                protocol: dietProtocol,
440                                isSamplingEvent: false
441                        ).with { if (!validate()) { errors.each { println it} } else save()}
442
443                        def eventBoost = new EventDescription(
444                                name: 'Boost treatment',
445                                description: 'Boost treatment (leptin or vehicle)',
446                                classification: treatmentTerm,
447                                protocol: boostProtocol,
448                                isSamplingEvent: false
449                        ).with { if (!validate()) { errors.each { println it} } else save()}
450
451                        def samplingEvent = new EventDescription(
452                                name: 'Liver extraction',
453                                description: 'Liver sampling for transcriptomics arrays',
454                                protocol: liverSamplingProtocol,
455                                isSamplingEvent: true
456                        ).with { if (!validate()) { errors.each { println it} } else save()}
457
458                        def bloodSamplingEventDescription = new EventDescription(
459                                name: 'Blood extraction',
460                                description: 'Blood extraction targeted at lipid assays',
461                                protocol: bloodSamplingProtocol,
462                                isSamplingEvent: true
463                        ).with { if (!validate()) { errors.each { println it} } else save()}
464
465
466            def fastingTreatment = new EventDescription(
467                                name: 'Fasting treatment',
468                                description: 'Fasting Protocol NuGO PPSH',
469                                protocol: fastingProtocol,
470                                isSamplingEvent: false
471                        ).with { if (!validate()) { errors.each { println it} } else save()}
472
473                        println('Adding PPS3 study...')
474                        */
475                        // studies
476                        println ".adding NuGO PPS3 leptin example study..."
477                        def exampleStudy = new Study(
478                                template: studyTemplate,
479                                title:"NuGO PPS3 mouse study leptin module",
480                                code:"PPS3_leptin_module",
481                                researchQuestion:"Leptin etc.",
482                                ecCode:"2007117.c",
483                                startDate: Date.parse('yyyy-MM-dd','2007-12-11')
484                        )
485                        .with { if (!validate()) { errors.each { println it} } else save()}
486
487                        exampleStudy.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." )
488                        exampleStudy.save()
489
490                        println ".adding NuGO PPSH example study..."
491                        def exampleHumanStudy = new Study(
492                                template: studyTemplate,
493                                title:"Human example template",
494                                code:"Human example code",
495                                researchQuestion:"Leptin etc.",
496                                ecCode:"2007117.c",
497                                startDate: Date.parse('yyyy-MM-dd','2007-12-11')
498                        )
499                        .with { if (!validate()) { errors.each { println it} } else save()}
500
501                        exampleHumanStudy.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." )
502                        exampleHumanStudy.save()
503
504                        def evLF = new Event(
505                                startTime: Date.parse('yyyy-MM-dd','2008-01-07'),
506                                endTime: Date.parse('yyyy-MM-dd','2008-01-14'),
507                                template: dietTreatmentTemplate
508                        )
509                        .with { if (!validate()) { errors.each { println it} } else save()}
510                        evLF.setFieldValue( 'Diet','10% fat (palm oil)' )
511                        evLF.save(flush:true)
512
513                        def evHF = new Event(
514                                startTime: Date.parse('yyyy-MM-dd','2008-01-07'),
515                                endTime: Date.parse('yyyy-MM-dd','2008-01-14'),
516                                template: dietTreatmentTemplate
517                        )
518                        .setFieldValue( 'Diet','45% fat (palm oil)' )
519                        .with { if (!validate()) { errors.each { println it} } else save()}
520
521                        def evBV = new Event(
522                                startTime: Date.parse('yyyy-MM-dd','2008-01-07'),
523                                endTime: Date.parse('yyyy-MM-dd','2008-01-14'),
524                                template: boostTreatmentTemplate
525                        )
526                        .setFieldValue( 'Compound','Vehicle' )
527                        .with { if (!validate()) { errors.each { println it} } else save()}
528
529                        def evBL = new Event(
530                                startTime: Date.parse('yyyy-MM-dd','2008-01-07'),
531                                endTime: Date.parse('yyyy-MM-dd','2008-01-14'),
532                                template: boostTreatmentTemplate
533                        )
534                        .setFieldValue( 'Compound','Leptin' )
535                        .with { if (!validate()) { errors.each { println it} } else save()}
536
537                        /*
538                        def evLF4 = new Event(
539                                startTime: Date.parse('yyyy-MM-dd','2008-01-07'),
540                                endTime: Date.parse('yyyy-MM-dd','2008-02-04'),
541                                eventDescription: eventDiet,
542                                parameterStringValues: ['Diet':'10% fat (palm oil)']
543                        ).with { if (!validate()) { errors.each { println it} } else save()}
544
545                        def evHF4 = new Event(
546                                startTime: Date.parse('yyyy-MM-dd','2008-01-07'),
547                                endTime: Date.parse('yyyy-MM-dd','2008-02-04'),
548                                eventDescription: eventDiet,
549                                parameterStringValues: ['Diet':'45% fat (palm oil)']
550                        ).with { if (!validate()) { errors.each { println it} } else save()}
551
552                        def evBV4 = new Event(
553                                startTime: Date.parse('yyyy-MM-dd','2008-01-07'),
554                                endTime: Date.parse('yyyy-MM-dd','2008-02-04'),
555                                eventDescription: eventBoost,
556                                parameterStringValues: ['Compound':'Vehicle']
557                        ).with { if (!validate()) { errors.each { println it} } else save()}
558
559                        def evBL4 = new Event(
560                                startTime: Date.parse('yyyy-MM-dd','2008-01-07'),
561                                endTime: Date.parse('yyyy-MM-dd','2008-02-04'),
562                                eventDescription: eventBoost,
563                                parameterStringValues: ['Compound':'Leptin']
564                        ).with { if (!validate()) { errors.each { println it} } else save()}
565
566                        def evS = new SamplingEvent(
567                                        startTime: Date.parse('yyyy-MM-dd','2008-01-14'),
568                                        endTime: Date.parse('yyyy-MM-dd','2008-01-14'),
569                                        eventDescription: samplingEvent,
570                                        parameterFloatValues: ['Sample weight':5F]
571                        ).with { if (!validate()) { errors.each { println it} } else save()}
572
573                        def evS4 = new SamplingEvent(
574                                        startTime: Date.parse('yyyy-MM-dd','2008-02-04'),
575                                        endTime: Date.parse('yyyy-MM-dd','2008-02-04'),
576                                        eventDescription: samplingEvent,
577                                        parameterFloatValues: ['Sample weight':5F]
578                        ).with { if (!validate()) { errors.each { println it} } else save()}
579                        */
580
581                        // Add events to study
582                        exampleStudy
583                        .addToEvents(evLF)
584                        .addToEvents(evHF)
585                        .addToEvents(evBV)
586                        .addToEvents(evBL)
587                        /*
588                        .addToEvents(evLF4)
589                        .addToEvents(evHF4)
590                        .addToEvents(evBV4)
591                        .addToEvents(evBL4)
592                        .addToSamplingEvents(evS)
593                        .addToSamplingEvents(evS4)
594                        */
595                        .save()
596
597                        def LFBV1 = new EventGroup(name:"10% fat + vehicle for 1 week")
598                        .addToEvents(evLF)
599                        .addToEvents(evBV)
600                        .with { if (!validate()) { errors.each { println it} } else save()}
601
602                        def LFBL1 = new EventGroup(name:"10% fat + leptin for 1 week")
603                        .addToEvents(evLF)
604                        .addToEvents(evBL)
605                        .with { if (!validate()) { errors.each { println it} } else save()}
606
607                        def HFBV1 = new EventGroup(name:"45% fat + vehicle for 1 week")
608                        .addToEvents(evHF)
609                        .addToEvents(evBV)
610                        .with { if (!validate()) { errors.each { println it} } else save()}
611
612                        def HFBL1 = new EventGroup(name:"45% fat + leptin for 1 week")
613                        .addToEvents(evHF)
614                        .addToEvents(evBL)
615                        .with { if (!validate()) { errors.each { println it} } else save()}
616
617                        /*
618                        def LFBV4 = new EventGroup(name:"10% fat + vehicle for 4 weeks")
619                        .addToEvents(evLF4)
620                        .addToEvents(evBV4)
621                        .with { if (!validate()) { errors.each { println it} } else save()}
622
623                        def LFBL4 = new EventGroup(name:"10% fat + leptin for 4 weeks")
624                        .addToEvents(evLF4)
625                        .addToEvents(evBL4)
626                        .with { if (!validate()) { errors.each { println it} } else save()}
627
628                        def HFBV4 = new EventGroup(name:"45% fat + vehicle for 4 weeks")
629                        .addToEvents(evHF4)
630                        .addToEvents(evBV4)
631                        .with { if (!validate()) { errors.each { println it} } else save()}
632
633                        def HFBL4 = new EventGroup(name:"45% fat + leptin for 4 weeks")
634                        .addToEvents(evHF4)
635                        .addToEvents(evBL4)
636                        .with { if (!validate()) { errors.each { println it} } else save()}
637                        */
638
639            // Add subjects and samples and compose EventGroups
640
641                        def x=1
642                        40.times {
643                                def currentSubject = new Subject(
644                                        name: "A" + x++,
645                                        species: mouseTerm,
646                                        template: mouseTemplate,
647                                )
648                                .setFieldValue("Gender", "Male")
649                                //.setFieldValue("Genotype", c57bl6Term)
650                                .setFieldValue("Age (weeks)", 17)
651                                .setFieldValue("Cage", "" + (int)(x/2))
652                                .with { if (!validate()) { errors.each { println it} } else save(flush:true)}
653
654                                exampleStudy.addToSubjects(currentSubject)
655                                .with { if (!validate()) { errors.each { println it} } else save()}
656
657                                // Add subject to appropriate EventGroup
658                                /*
659                                if (x > 70) { HFBL4.addToSubjects(currentSubject).save() }
660                                else if (x > 60) { HFBV4.addToSubjects(currentSubject).save() }
661                                else if (x > 50) { LFBL4.addToSubjects(currentSubject).save() }
662                                else if (x > 40) { LFBV4.addToSubjects(currentSubject).save() }
663                                else if (x > 30) { HFBL1.addToSubjects(currentSubject).save() }
664                                else if (x > 20) { HFBV1.addToSubjects(currentSubject).save() }
665                                else if (x > 10) { LFBL1.addToSubjects(currentSubject).save() }
666                                else             { LFBV1.addToSubjects(currentSubject).save() }
667                                */
668
669                                if (x > 30) { HFBL1.addToSubjects(currentSubject).save() }
670                                else if (x > 20) { HFBV1.addToSubjects(currentSubject).save() }
671                                else if (x > 10) { LFBL1.addToSubjects(currentSubject).save() }
672                                else             { LFBV1.addToSubjects(currentSubject).save() }
673
674                        }
675
676                        // Add EventGroups to study
677                        exampleStudy
678                        .addToEventGroups(LFBV1)
679                        .addToEventGroups(LFBL1)
680                        .addToEventGroups(HFBV1)
681                        .addToEventGroups(HFBL1)
682                        //.addToEventGroups(LFBV4)
683                        //.addToEventGroups(LFBL4)
684                        //.addToEventGroups(HFBV4)
685                        //.addToEventGroups(HFBL4)
686
687                        // Add persons to study
688                        def studyperson1 = new StudyPerson( person: person1, role: role1 ).save();
689                        def studyperson2 = new StudyPerson( person: person2, role: role2 ).save();
690
691                        exampleStudy
692                        .addToPersons( studyperson1 )
693                        .addToPersons( studyperson2 )
694                        .save()
695                       
696                        /*
697                        println 'Adding PPSH study'
698
699                        def humanStudy = new Study(
700                                template: studyTemplate,
701                                title:"NuGO PPS human study",
702                                code:"PPSH",
703                                researchQuestion:"How much are fasting plasma and urine metabolite levels affected by prolonged fasting ?",
704                                description:"Human study",
705                                ecCode:"unknown",
706                                startDate: Date.parse('yyyy-MM-dd','2009-01-01')
707                        ).with { if (!validate()) { errors.each { println it} } else save()}
708
709                        def fastingEvent = new Event(
710                                        startTime: Date.parse('yyyy-MM-dd','2008-01-14'),
711                                        endTime: Date.parse('yyyy-MM-dd','2008-01-14'),
712                                        eventDescription: fastingTreatment,
713                                        parameterStringValues: ['Fasting period':'8h']);
714
715                        def bloodSamplingEvent = new SamplingEvent(
716                                        startTime: Date.parse('yyyy-MM-dd','2008-01-14'),
717                                        endTime: Date.parse('yyyy-MM-dd','2008-01-14'),
718                                        eventDescription: bloodSamplingEventDescription,
719                                        parameterFloatValues: ['Sample volume':4.5F]);
720
721                        def rootGroup = new EventGroup(name: 'Root group');
722                        rootGroup.addToEvents fastingEvent
723                        rootGroup.addToEvents bloodSamplingEvent
724                        rootGroup.save()
725
726            def y = 1
727            11.times {
728              def currentSubject = new Subject(
729                      name: "" + y++,
730                      species: humanTerm,
731                      template: humanTemplate).setFieldValue("Gender", (boolean) (x / 2) ? "Male" : "Female").setFieldValue("DOB", new java.text.SimpleDateFormat("dd-mm-yy").parse("01-02-19" + (10 + (int) (Math.random() * 80)))).setFieldValue("Age (years)", 30).setFieldValue("Height", Math.random() * 2F).setFieldValue("Weight (kg)", Math.random() * 150F).setFieldValue("BMI", 20 + Math.random() * 10F).with { if (!validate()) { errors.each { println it} } else save()}
732
733              rootGroup.addToSubjects currentSubject
734              rootGroup.save()
735
736              def currentSample = new Sample(
737                      name: currentSubject.name + '_B',
738                      material: bloodTerm,
739                      parentSubject: currentSubject,
740                      parentEvent: bloodSamplingEvent);
741
742
743              humanStudy.addToSubjects(currentSubject).addToSamples(currentSample).with { if (!validate()) { errors.each { println it} } else save()}
744          }
745
746          humanStudy.addToEvents(fastingEvent)
747          humanStudy.addToSamplingEvents(bloodSamplingEvent)
748          humanStudy.addToEventGroups rootGroup
749          humanStudy.save()
750
751                        // Add clinical data
752
753                        def lipidAssay = new dbnp.clinicaldata.ClinicalAssay(
754                                name: 'Lipid profile',
755                                approved: true
756                        ).with { if (!validate()) { errors.each { println it} } else save()}
757
758                        def ldlMeasurement = new dbnp.clinicaldata.ClinicalMeasurement(
759                                name: 'LDL',
760                                unit: 'mg/dL',
761                                type: dbnp.data.FeatureType.QUANTITATIVE,
762                                referenceValues: '100 mg/dL',
763                                detectableLimit: 250,
764                                isDrug: false, isIntake: true, inSerum: true
765                        ).with { if (!validate()) { errors.each { println it} } else save()}
766
767                        def hdlMeasurement = new dbnp.clinicaldata.ClinicalMeasurement(
768                                name: 'HDL',
769                                unit: 'mg/dL',
770                                type: dbnp.data.FeatureType.QUANTITATIVE,
771                                referenceValues: '50 mg/dL',
772                                detectableLimit: 100,
773                                isDrug: false, isIntake: true, inSerum: true
774                        ).with { if (!validate()) { errors.each { println it} } else save()}
775
776                        lipidAssay.addToMeasurements ldlMeasurement
777                        lipidAssay.addToMeasurements hdlMeasurement
778
779                        def lipidAssayInstance = new dbnp.clinicaldata.ClinicalAssayInstance(
780                                assay: lipidAssay
781                        ).with { if (!validate()) { errors.each { println it} } else save()}
782
783                        humanStudy.samples*.each {
784                                new dbnp.clinicaldata.ClinicalFloatData(
785                                        assay: lipidAssayInstance,
786                                        measurement: ldlMeasurement,
787                                        sample: it.name,
788                                        value: Math.round(Math.random()*ldlMeasurement.detectableLimit)
789                                ).with { if (!validate()) { errors.each { println it} } else save()}
790
791                                new dbnp.clinicaldata.ClinicalFloatData(
792                                        assay: lipidAssayInstance,
793                                        measurement: hdlMeasurement,
794                                        sample: it.name,
795                                        value: Math.round(Math.random()*hdlMeasurement.detectableLimit)
796                                ).with { if (!validate()) { errors.each { println it} } else save()}
797                        }
798
799                        // Add assay to study capture module
800
801                        def clinicalModule = new AssayModule(
802                                name: 'Clinical data',
803                                type: AssayType.CLINICAL_DATA,
804                                platform: 'clinical measurements',
805                                url: 'http://localhost:8080/gscf'
806                        ).with { if (!validate()) { errors.each { println it} } else save()}
807
808                        def lipidAssayRef = new Assay(
809                                name: 'Lipid profiling',
810                                module: clinicalModule,
811                                externalAssayId: lipidAssayInstance.id
812                        ).with { if (!validate()) { errors.each { println it} } else save()}
813
814                        humanStudy.samples*.each {
815                                lipidAssayRef.addToSamples(it)
816                        }
817                        lipidAssayRef.save()
818
819                        humanStudy.addToAssays(lipidAssayRef);
820                        humanStudy.save()
821*/
822                }
823        }
824
825        def destroy = {
826        }
827}
Note: See TracBrowser for help on using the browser.