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

Last change on this file since 443 was 442, checked in by roberth, 12 years ago

Updated studies list and added institute and department properties to person affiliations

  • Property svn:keywords set to Author Rev Date
File size: 26.9 KB
Line 
1import dbnp.studycapturing.*
2
3import dbnp.data.Ontology
4import dbnp.data.Term
5import org.codehaus.groovy.grails.commons.GrailsApplication
6
7/**
8 * Application Bootstrapper
9 * @Author Jeroen Wesbeek
10 * @Since 20091021
11 *
12 * Revision information:
13 * $Rev: 442 $
14 * $Author: duh $
15 * $Date: 2010-05-19 16:12:42 +0000 (wo, 19 mei 2010) $
16 */
17class BootStrap {
18        def init = {servletContext ->
19                // define timezone
20                System.setProperty('user.timezone', 'CET')
21
22                // we could also check if we are in development by GrailsUtil.environment == GrailsApplication.ENV_DEVELOPMENT
23                if (Study.count() == 0) {
24                        println ".development bootstrapping...";
25
26                        // add Subject>species ontology
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()}
36
37                        // add Sample>material ontology
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
48                        // add NCI ontology which is used in Mouse genotype template field
49                        def nciOntology = new Ontology(
50                                name: 'NCI Thesaurus',
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'
56                        ).with { if (!validate()) { errors.each { println it} } else save()}
57                       
58                        // add Terms
59                        println ".adding mouse term"
60                        def mouseTerm = new Term(
61                                name: 'Mus musculus',
62                                ontology: speciesOntology,
63                                accession: '10090'
64                        ).with { if (!validate()) { errors.each { println it} } else save()}
65                        println ".adding human term"
66                        def humanTerm = new Term(
67                                name: 'Homo sapiens',
68                                ontology: speciesOntology,
69                                accession: '9606'
70                        ).with { if (!validate()) { errors.each { println it} } else save()}
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()}
76
77                        def bloodTerm = new Term(
78                                name: 'blood plasma',
79                                ontology: brendaOntology,
80                                accession: 'BTO:0000131'
81                        ).with { if (!validate()) { errors.each { println it} } else save()}
82
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
89                        // Create a few persons, roles and Affiliations
90                        println ".adding persons, roles and affiliations"
91                        def affiliation1 = new PersonAffiliation(
92                            institute: "Science Institute NYC",
93                            department: "Department of Mathematics"
94                        ).save();
95                        def affiliation2 = new PersonAffiliation(
96                            institute: "InfoStats GmbH, Hamburg",
97                            department: "Life Sciences"
98                        ).save();
99                        def role1 = new PersonRole(
100                            name: "Principal Investigator"
101                        ).save();
102                        def role2 = new PersonRole(
103                            name: "Statician"
104                        ).save();
105
106                        // Create 30 roles to test pagination
107                        def roleCounter = 1;
108                        30.times { new PersonRole( name: "Rol #${roleCounter++}" ).save() }
109
110                        // Create persons
111                        def person1 = new Person(
112                            lastName: "Scientist",
113                            firstName: "John",
114                            gender: "Male",
115                            initials: "J.R.",
116                            email: "john@scienceinstitute.com",
117                            phone: "1-555-3049",
118                            address: "First street 2,NYC"
119                        )
120                        .addToAffiliations( affiliation1 )
121                        .addToAffiliations( affiliation2 )
122                        .save();
123
124                        def person2 = new Person(
125                            lastName: "Statician",
126                            firstName: "Jane",
127                            gender: "Female",
128                            initials: "W.J.",
129                            email: "jane@statisticalcompany.de",
130                            phone: "49-555-8291",
131                            address: "Dritten strasse 38, Hamburg, Germany"
132                        )
133                        .addToAffiliations( affiliation2 )
134                        .save();
135
136                        // Create 30 persons to test pagination
137                        def personCounter = 1;
138                        30.times { new Person( firstName: "Person #${personCounter}", lastName: "Testperson", email: "email${personCounter++}@testdomain.com" ).save() }
139
140                        // Create templates
141
142                        def genderField = new TemplateField(
143                                name: 'Gender',type: TemplateFieldType.STRINGLIST,
144                                listEntries: [new TemplateFieldListItem(name:'Male'),new TemplateFieldListItem(name: 'Female')])
145                        .with { if (!validate()) { errors.each { println it} } else save()}
146
147                        def ageField = new TemplateField(
148                                name: 'Age (years)',type: TemplateFieldType.INTEGER,unit: 'years')
149                        .with { if (!validate()) { errors.each { println it} } else save()}
150
151                        def genotypeField = new TemplateField(
152                                name: 'Genotype', type: TemplateFieldType.ONTOLOGYTERM)
153                        .with { if (!validate()) { errors.each { println it} } else save()}
154
155                        def genotypeTypeField = new TemplateField(
156                                name: 'Genotype type',type: TemplateFieldType.STRINGLIST,
157                                listEntries: [new TemplateFieldListItem(name:'wildtype'),
158                                        new TemplateFieldListItem(name:'transgenic'),
159                                        new TemplateFieldListItem(name:'knock-out'),
160                                        new TemplateFieldListItem(name:'knock-in')])
161                        .with { if (!validate()) { errors.each { println it} } else save()}
162
163
164                        // Nutritional study template
165
166                        println ".adding academic study template..."
167                        def studyTemplate = new Template(
168                                name: 'Academic study', entity: dbnp.studycapturing.Study)
169                                .addToFields(new TemplateField(name: 'Description',type: TemplateFieldType.TEXT))
170                                .addToFields(new TemplateField(name: 'Study code',type: TemplateFieldType.STRING, preferredIdentifier:true))
171                                .addToFields(new TemplateField(name: 'Objectives',type: TemplateFieldType.TEXT))
172                                .addToFields(new TemplateField(name: 'Consortium',type: TemplateFieldType.STRING))
173                                .addToFields(new TemplateField(name: 'Cohort name',type: TemplateFieldType.STRING))
174                                .addToFields(new TemplateField(name: 'Time zone',type: TemplateFieldType.STRING))
175                                .addToFields(new TemplateField(name: 'Responsible scientist',type: TemplateFieldType.STRING))
176                                .addToFields(new TemplateField(name: 'Lab id',type: TemplateFieldType.STRING))
177                                .addToFields(new TemplateField(name: 'Institute',type: TemplateFieldType.STRING))
178                        .with { if (!validate()) { errors.each { println it} } else save()}
179
180                        // Mouse template
181                        println ".adding mouse subject template..."
182                        def mouseTemplate = new Template(
183                                name: 'Mouse', entity: dbnp.studycapturing.Subject)
184                        .addToFields(new TemplateField(
185                                name: 'Strain', type: TemplateFieldType.ONTOLOGYTERM))
186                        .addToFields(genotypeField)
187                        .addToFields(genotypeTypeField)
188                        .addToFields(genderField)
189                        .addToFields(new TemplateField(
190                                name: 'Age (weeks)', type: TemplateFieldType.INTEGER, unit: 'weeks'))
191                        .addToFields(new TemplateField(
192                                name: 'Age type',type: TemplateFieldType.STRINGLIST,
193                                listEntries: [new TemplateFieldListItem(name:'postnatal'),new TemplateFieldListItem(name:'embryonal')]))
194                        .addToFields(new TemplateField(
195                                name: 'Cage',type: TemplateFieldType.STRING))
196                        .addToFields(new TemplateField(
197                                name: '#Mice in cage',type: TemplateFieldType.INTEGER))
198                        .addToFields(new TemplateField(
199                                name: 'Litter size',type: TemplateFieldType.INTEGER))
200                        .addToFields(new TemplateField(
201                                name: 'Weight (g)', type: TemplateFieldType.DOUBLE, unit: 'gram'))
202                        .with { if (!validate()) { errors.each { println it} } else save()}
203
204                        // Human template
205                        println ".adding human subject template..."
206                        def humanTemplate = new Template(
207                                name: 'Human', entity: dbnp.studycapturing.Subject)
208                        .addToFields(genderField)
209                        .addToFields(ageField)
210                        .addToFields(new TemplateField(
211                                name: 'DOB',type: TemplateFieldType.DATE))
212                        .addToFields(new TemplateField(
213                                name: 'Height',type: TemplateFieldType.DOUBLE, unit: 'm'))
214                        .addToFields(new TemplateField(
215                                name: 'Weight (kg)',type: TemplateFieldType.DOUBLE, unit: 'kg'))
216                        .addToFields(new TemplateField(
217                                name: 'BMI',type: TemplateFieldType.DOUBLE, unit: 'kg/m2'))
218                        .addToFields(new TemplateField(
219                                name: 'Race',type: TemplateFieldType.STRING))
220                        .addToFields(new TemplateField(
221                                name: 'Waist circumference',type: TemplateFieldType.FLOAT, unit: 'cm'))
222                        .addToFields(new TemplateField(
223                                name: 'Hip circumference',type: TemplateFieldType.FLOAT, unit: 'cm'))
224                        .addToFields(new TemplateField(
225                                name: 'Systolic blood pressure',type: TemplateFieldType.FLOAT, unit: 'mmHg'))
226                        .addToFields(new TemplateField(
227                                name: 'Diastolic blood pressure',type: TemplateFieldType.FLOAT, unit: 'mmHg'))
228                        .addToFields(new TemplateField(
229                                name: 'Heart rate',type: TemplateFieldType.FLOAT, unit: 'beats/min'))
230                        .addToFields(new TemplateField(
231                                name: 'Run-in-food',type: TemplateFieldType.TEXT))
232                        .with { if (!validate()) { errors.each { println it} } else save()}
233
234
235                        def sampleDescriptionField = new TemplateField(
236                                name: 'Description',type: TemplateFieldType.TEXT)
237                        .with { if (!validate()) { errors.each { println it} } else save()}
238                        def sampleTypeField = new TemplateField(
239                                name: 'SampleType',type: TemplateFieldType.STRING)
240                        .with { if (!validate()) { errors.each { println it} } else save()}
241                        def sampleProtocolField = new TemplateField(
242                                name: 'SampleProtocol',type: TemplateFieldType.STRING)
243                        .with { if (!validate()) { errors.each { println it} } else save()}
244                        def sampleVialTextField = new TemplateField(
245                                name: 'Text on vial',type: TemplateFieldType.STRING)
246                        .with { if (!validate()) { errors.each { println it} } else save()}
247
248                        // Human sample template
249                        println ".adding human sample template..."
250                        def humanSampleTemplate = new Template(
251                                name: 'Human tissue sample', entity: dbnp.studycapturing.Sample)
252                        .addToFields(sampleDescriptionField)
253                        .addToFields(sampleTypeField)
254                        .addToFields(sampleProtocolField)
255                        .addToFields(sampleVialTextField)
256                        .with { if (!validate()) { errors.each { println it} } else save()}
257
258                        //Plant template
259                        println ".adding plant template..."
260                        def plantTemplate = new Template(
261                                name: 'Plant template', entity: dbnp.studycapturing.Subject)
262                        .addToFields(new TemplateField(
263                                name: 'Variety', type: TemplateFieldType.STRING))
264                        .addToFields(new TemplateField(
265                                name: 'Ecotype', type: TemplateFieldType.STRING))
266                        .addToFields(genotypeField)
267                        .addToFields(genotypeTypeField)
268                        .addToFields(new TemplateField(
269                                name: 'Growth location', type: TemplateFieldType.STRINGLIST,
270                                listEntries: [new TemplateFieldListItem(name:'Greenhouse'),new TemplateFieldListItem(name: 'Field')]))
271                        .addToFields(new TemplateField(
272                                name: 'Room', type: TemplateFieldType.STRING,
273                                comment: 'Chamber number in case of Greenhouse'))
274                        .addToFields(new TemplateField(
275                                name: 'Position X', type: TemplateFieldType.FLOAT))
276                        .addToFields(new TemplateField(
277                                name: 'Position Y', type: TemplateFieldType.FLOAT))
278                        .addToFields(new TemplateField(
279                                name: 'Block', type: TemplateFieldType.STRING))
280                        .addToFields(new TemplateField(
281                                name: 'Temperature at day', type: TemplateFieldType.FLOAT))
282                        .addToFields(new TemplateField(
283                                name: 'Temperature at night', type: TemplateFieldType.FLOAT))
284                        .addToFields(new TemplateField(
285                                name: 'Photo period', type: TemplateFieldType.STRING))
286                        .addToFields(new TemplateField(
287                                name: 'Light intensity', type: TemplateFieldType.STRING))
288                        .addToFields(new TemplateField(
289                                name: 'Start date', type: TemplateFieldType.DATE))
290                        .addToFields(new TemplateField(
291                                name: 'Harvest date', type: TemplateFieldType.DATE))
292                        .addToFields(new TemplateField(
293                                name: 'Growth type', type: TemplateFieldType.STRINGLIST,
294                                listEntries: [new TemplateFieldListItem(name:'Standard'),new TemplateFieldListItem(name: 'Experimental')]))
295                        .addToFields(new TemplateField(
296                                name: 'Growth protocol', type: TemplateFieldType.TEXT))
297                        .addToFields(new TemplateField(
298                                name: 'Harvest delay', type: TemplateFieldType.TEXT))
299                        .with { if (!validate()) { errors.each { println it} } else save()}
300
301                        println ".adding plant sample template..."
302                        def plantSampleTemplate = new Template(
303                                name: 'Plant sample', entity: dbnp.studycapturing.Sample)
304                        .addToFields(sampleDescriptionField)
305                        .addToFields(sampleTypeField)
306                        .addToFields(sampleProtocolField)
307                        .addToFields(sampleVialTextField)
308                        .with { if (!validate()) { errors.each { println it} } else save()}
309
310
311                        // Event templates
312                        def dietTreatmentTemplate = new Template(
313                                name: 'Diet treatment', entity: dbnp.studycapturing.Event)
314                        .addToFields(sampleDescriptionField)
315                        .addToFields(new TemplateField(
316                                name: 'Diet', type: TemplateFieldType.STRINGLIST,
317                                listEntries: [new TemplateFieldListItem(name:'10% fat (palm oil)'),new TemplateFieldListItem(name: '45% fat (palm oil)')]))
318                        .with { if (!validate()) { errors.each { println it} } else save()}
319
320                        def boostTreatmentTemplate = new Template(
321                                name: 'Boost treatment', entity: dbnp.studycapturing.Event)
322                        .addToFields(sampleDescriptionField)
323                        .addToFields(new TemplateField(
324                                name: 'Compound', type: TemplateFieldType.STRING,
325                                listEntries: [new TemplateFieldListItem(name:'Vehicle'),new TemplateFieldListItem(name: 'Leptin')]))
326                        .with { if (!validate()) { errors.each { println it} } else save()}
327
328                        def fastingTreatment = new Template(
329                                 name: 'Fasting treatment',
330                                 description: 'Fasting Protocol NuGO PPSH',
331                                 entity: dbnp.studycapturing.Event)
332                         .addToFields(new TemplateField(
333                                 name: 'Fasting period',
334                                 type: TemplateFieldType.STRING))
335                         .with { if (!validate()) { errors.each { println it} } else save()}
336
337                        // SamplingEvent templates
338
339                        def liverSamplingEventTemplate = new Template(
340                                name: 'Liver extraction',
341                                description: 'Liver sampling for transcriptomics arrays',
342                                entity: dbnp.studycapturing.SamplingEvent)
343                        .addToFields(new TemplateField(
344                                name: 'Sample weight',
345                                unit: 'mg',
346                                type: TemplateFieldType.FLOAT))
347                        .with { if (!validate()) { errors.each { println it} } else save()}
348
349                        def bloodSamplingEventTemplate = new Template(
350                                name: 'Blood extraction',
351                                description: 'Blood extraction targeted at lipid assays',
352                                entity: dbnp.studycapturing.SamplingEvent)
353                        .addToFields(new TemplateField(
354                                name: 'Sample volume',
355                                unit: 'ml',
356                                type: TemplateFieldType.FLOAT))
357                        .with { if (!validate()) { errors.each { println it} } else save()}
358
359
360                        // Add example studies
361                        if (!(grails.util.GrailsUtil.environment == GrailsApplication.ENV_TEST)) {
362                                println ".adding NuGO PPS3 leptin example study..."
363                                def mouseStudy = new Study(
364                                        template: studyTemplate,
365                                        title:"NuGO PPS3 mouse study leptin module",
366                                        code:"PPS3_leptin_module",
367                                        researchQuestion:"Leptin etc.",
368                                        ecCode:"2007117.c",
369                                        startDate: Date.parse('yyyy-MM-dd','2007-12-11')
370                                )
371                                .with { if (!validate()) { errors.each { println it} } else save()}
372
373                                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." )
374                                mouseStudy.save()
375
376                                def evLF = new Event(
377                                        startTime: Date.parse('yyyy-MM-dd','2008-01-07'),
378                                        endTime: Date.parse('yyyy-MM-dd','2008-01-14'),
379                                        template: dietTreatmentTemplate
380                                )
381                                .setFieldValue( 'Diet','10% fat (palm oil)')
382                                .with { if (!validate()) { errors.each { println it} } else save()}
383
384                                def evHF = new Event(
385                                        startTime: Date.parse('yyyy-MM-dd','2008-01-07'),
386                                        endTime: Date.parse('yyyy-MM-dd','2008-01-14'),
387                                        template: dietTreatmentTemplate
388                                )
389                                .setFieldValue( 'Diet','45% fat (palm oil)' )
390                                .with { if (!validate()) { errors.each { println it} } else save()}
391
392                                def evBV = new Event(
393                                        startTime: Date.parse('yyyy-MM-dd','2008-01-07'),
394                                        endTime: Date.parse('yyyy-MM-dd','2008-01-14'),
395                                        template: boostTreatmentTemplate
396                                )
397                                .setFieldValue( 'Compound','Vehicle' )
398                                .with { if (!validate()) { errors.each { println it} } else save()}
399
400                                def evBL = new Event(
401                                        startTime: Date.parse('yyyy-MM-dd','2008-01-07'),
402                                        endTime: Date.parse('yyyy-MM-dd','2008-01-14'),
403                                        template: boostTreatmentTemplate
404                                )
405                                .setFieldValue( 'Compound','Leptin' )
406                                .with { if (!validate()) { errors.each { println it} } else save()}
407
408                                def evLF4 = new Event(
409                                        startTime: Date.parse('yyyy-MM-dd','2008-01-07'),
410                                        endTime: Date.parse('yyyy-MM-dd','2008-02-04'),
411                                        template: dietTreatmentTemplate
412                                )
413                                .setFieldValue( 'Diet','10% fat (palm oil)')
414                                .with { if (!validate()) { errors.each { println it} } else save()}
415
416                                def evHF4 = new Event(
417                                        startTime: Date.parse('yyyy-MM-dd','2008-01-07'),
418                                        endTime: Date.parse('yyyy-MM-dd','2008-02-04'),
419                                        template: dietTreatmentTemplate
420                                )
421                                .setFieldValue( 'Diet','45% fat (palm oil)' )
422                                .with { if (!validate()) { errors.each { println it} } else save()}
423
424                                def evBV4 = new Event(
425                                        startTime: Date.parse('yyyy-MM-dd','2008-01-07'),
426                                        endTime: Date.parse('yyyy-MM-dd','2008-02-04'),
427                                        template: boostTreatmentTemplate
428                                )
429                                .setFieldValue( 'Compound','Vehicle' )
430                                .with { if (!validate()) { errors.each { println it} } else save()}
431
432                                def evBL4 = new Event(
433                                        startTime: Date.parse('yyyy-MM-dd','2008-01-07'),
434                                        endTime: Date.parse('yyyy-MM-dd','2008-02-04'),
435                                        template: boostTreatmentTemplate
436                                )
437                                .setFieldValue( 'Compound','Leptin' )
438                                .with { if (!validate()) { errors.each { println it} } else save()}
439
440                                def evS = new SamplingEvent(
441                                        startTime: Date.parse('yyyy-MM-dd','2008-01-14'),
442                                        endTime: Date.parse('yyyy-MM-dd','2008-01-14'),
443                                        template: liverSamplingEventTemplate)
444                                .setFieldValue('Sample weight',5F)
445                                .with { if (!validate()) { errors.each { println it} } else save()}
446
447                                def evS4 = new SamplingEvent(
448                                        startTime: Date.parse('yyyy-MM-dd','2008-01-14'),
449                                        endTime: Date.parse('yyyy-MM-dd','2008-01-14'),
450                                        template: liverSamplingEventTemplate)
451                                .setFieldValue('Sample weight',5F)
452                                .with { if (!validate()) { errors.each { println it} } else save()}
453
454                                // Add events to study
455                                mouseStudy
456                                .addToEvents(evLF)
457                                .addToEvents(evHF)
458                                .addToEvents(evBV)
459                                .addToEvents(evBL)
460                                .addToEvents(evLF4)
461                                .addToEvents(evHF4)
462                                .addToEvents(evBV4)
463                                .addToEvents(evBL4)
464                                .addToSamplingEvents(evS)
465                                .addToSamplingEvents(evS4)
466                                .save()
467
468                                def LFBV1 = new EventGroup(name:"10% fat + vehicle for 1 week")
469                                .addToEvents(evLF)
470                                .addToEvents(evBV)
471                                .addToEvents(evS)
472                                .with { if (!validate()) { errors.each { println it} } else save()}
473
474                                def LFBL1 = new EventGroup(name:"10% fat + leptin for 1 week")
475                                .addToEvents(evLF)
476                                .addToEvents(evBL)
477                                .addToEvents(evS)
478                                .with { if (!validate()) { errors.each { println it} } else save()}
479
480                                def HFBV1 = new EventGroup(name:"45% fat + vehicle for 1 week")
481                                .addToEvents(evHF)
482                                .addToEvents(evBV)
483                                .addToEvents(evS)
484                                .with { if (!validate()) { errors.each { println it} } else save()}
485
486                                def HFBL1 = new EventGroup(name:"45% fat + leptin for 1 week")
487                                .addToEvents(evHF)
488                                .addToEvents(evBL)
489                                .addToEvents(evS)
490                                .with { if (!validate()) { errors.each { println it} } else save()}
491
492                                def LFBV4 = new EventGroup(name:"10% fat + vehicle for 4 weeks")
493                                .addToEvents(evLF4)
494                                .addToEvents(evBV4)
495                                .addToEvents(evS4)
496                                .with { if (!validate()) { errors.each { println it} } else save()}
497
498                                def LFBL4 = new EventGroup(name:"10% fat + leptin for 4 weeks")
499                                .addToEvents(evLF4)
500                                .addToEvents(evBL4)
501                                .addToEvents(evS4)
502                                .with { if (!validate()) { errors.each { println it} } else save()}
503
504                                def HFBV4 = new EventGroup(name:"45% fat + vehicle for 4 weeks")
505                                .addToEvents(evHF4)
506                                .addToEvents(evBV4)
507                                .addToEvents(evS4)
508                                .with { if (!validate()) { errors.each { println it} } else save()}
509
510                                def HFBL4 = new EventGroup(name:"45% fat + leptin for 4 weeks")
511                                .addToEvents(evHF4)
512                                .addToEvents(evBL4)
513                                .addToEvents(evS4)
514                                .with { if (!validate()) { errors.each { println it} } else save()}
515
516                                // Add subjects and samples and compose EventGroups
517                                def x=1
518                                20.times {
519                                        def currentSubject = new Subject(
520                                                name: "A" + x++,
521                                                species: mouseTerm,
522                                                template: mouseTemplate,
523                                        )
524                                        .setFieldValue("Gender", "Male")
525                                        .setFieldValue("Genotype", c57bl6Term)
526                                        .setFieldValue("Age (weeks)", 17)
527                                        .setFieldValue("Cage", "" + (int)(x/2))
528                                        .with { if (!validate()) { errors.each { println it} } else save(flush:true)}
529
530                                        mouseStudy.addToSubjects(currentSubject)
531                                        .with { if (!validate()) { errors.each { println it} } else save()}
532
533                                        // Add subject to appropriate EventGroup
534                                        if (x > 70) { HFBL4.addToSubjects(currentSubject).save() }
535                                        else if (x > 60) { HFBV4.addToSubjects(currentSubject).save() }
536                                        else if (x > 50) { LFBL4.addToSubjects(currentSubject).save() }
537                                        else if (x > 40) { LFBV4.addToSubjects(currentSubject).save() }
538                                        else if (x > 30) { HFBL1.addToSubjects(currentSubject).save() }
539                                        else if (x > 20) { HFBV1.addToSubjects(currentSubject).save() }
540                                        else if (x > 10) { LFBL1.addToSubjects(currentSubject).save() }
541                                        else             { LFBV1.addToSubjects(currentSubject).save() }
542
543                                }
544
545                                // Add EventGroups to study
546                                mouseStudy
547                                .addToEventGroups(LFBV1)
548                                .addToEventGroups(LFBL1)
549                                .addToEventGroups(HFBV1)
550                                .addToEventGroups(HFBL1)
551                                .addToEventGroups(LFBV4)
552                                .addToEventGroups(LFBL4)
553                                .addToEventGroups(HFBV4)
554                                .addToEventGroups(HFBL4)
555
556                                // Add persons to study
557                                def studyperson1 = new StudyPerson( person: person1, role: role1 ).save();
558                                def studyperson2 = new StudyPerson( person: person2, role: role2 ).save();
559
560                                mouseStudy
561                                .addToPersons( studyperson1 )
562                                .addToPersons( studyperson2 )
563                                .save()
564
565                                println ".adding NuGO PPSH example study..."
566
567                                def humanStudy = new Study(
568                                        template: studyTemplate,
569                                        title:"NuGO PPS human study",
570                                        code:"PPSH",
571                                        researchQuestion:"How much are fasting plasma and urine metabolite levels affected by prolonged fasting ?",
572                                        description:"Human study",
573                                        ecCode:"unknown",
574                                        startDate: Date.parse('yyyy-MM-dd','2008-01-14'))
575                                .setFieldValue( 'Description', "Human study performed at RRI; centres involved: RRI, IFR, TUM, Maastricht U." )
576                                .with { if (!validate()) { errors.each { println it} } else save()}
577
578                                def rootGroup = new EventGroup(name: 'Root group');
579
580                                def fastingEvent = new Event(
581                                        startTime: Date.parse('yyyy-MM-dd HH:mm','2008-01-14 22:00'),
582                                        endTime: Date.parse('yyyy-MM-dd HH:mm','2008-01-15 08:00'),
583                                        template: fastingTreatment)
584                                .setFieldValue('Fasting period','8h');
585
586
587                                def bloodSamplingEvent = new SamplingEvent(
588                                        startTime: Date.parse('yyyy-MM-dd HH:mm','2008-01-15 08:00'),
589                                        endTime: Date.parse('yyyy-MM-dd HH:mm','2008-01-15 08:00'),
590                                        template: bloodSamplingEventTemplate)
591                                .setFieldValue('Sample volume',4.5F);
592
593                                rootGroup.addToEvents fastingEvent
594                                rootGroup.addToEvents bloodSamplingEvent
595                                rootGroup.save()
596
597                                def y = 1
598                                11.times {
599                                        def currentSubject = new Subject(
600                                              name: "" + y++,
601                                              species: humanTerm,
602                                              template: humanTemplate)
603                                        .setFieldValue("Gender", (Math.random() > 0.5) ? "Male" : "Female")
604                                        .setFieldValue("DOB", new java.text.SimpleDateFormat("dd-mm-yy").parse("01-02-19" + (10 + (int) (Math.random() * 80))))
605                                        .setFieldValue("Age (years)", 30)
606                                        .setFieldValue("Height", Math.random() * 2F)
607                                        .setFieldValue("Weight (kg)", Math.random() * 150F)
608                                        .setFieldValue("BMI", 20 + Math.random() * 10F)
609                                        .with { if (!validate()) { errors.each { println it} } else save()}
610
611                                        rootGroup.addToSubjects currentSubject
612                                        rootGroup.save()
613
614                                        def currentSample = new Sample(
615                                              name: currentSubject.name + '_B',
616                                              material: bloodTerm,
617                                              parentSubject: currentSubject,
618                                              parentEvent: bloodSamplingEvent);
619
620                                        humanStudy.addToSubjects(currentSubject).addToSamples(currentSample).with { if (!validate()) { errors.each { println it} } else save()}
621                                }
622
623                                humanStudy.addToEvents(fastingEvent)
624                                humanStudy.addToSamplingEvents(bloodSamplingEvent)
625                                humanStudy.addToEventGroups rootGroup
626                                humanStudy.save()
627
628                                /*
629                                // Add clinical data
630
631                                def lipidAssay = new dbnp.clinicaldata.ClinicalAssay(
632                                        name: 'Lipid profile',
633                                        approved: true
634                                ).with { if (!validate()) { errors.each { println it} } else save()}
635
636                                def ldlMeasurement = new dbnp.clinicaldata.ClinicalMeasurement(
637                                        name: 'LDL',
638                                        unit: 'mg/dL',
639                                        type: dbnp.data.FeatureType.QUANTITATIVE,
640                                        referenceValues: '100 mg/dL',
641                                        detectableLimit: 250,
642                                        isDrug: false, isIntake: true, inSerum: true
643                                ).with { if (!validate()) { errors.each { println it} } else save()}
644
645                                def hdlMeasurement = new dbnp.clinicaldata.ClinicalMeasurement(
646                                        name: 'HDL',
647                                        unit: 'mg/dL',
648                                        type: dbnp.data.FeatureType.QUANTITATIVE,
649                                        referenceValues: '50 mg/dL',
650                                        detectableLimit: 100,
651                                        isDrug: false, isIntake: true, inSerum: true
652                                ).with { if (!validate()) { errors.each { println it} } else save()}
653
654                                lipidAssay.addToMeasurements ldlMeasurement
655                                lipidAssay.addToMeasurements hdlMeasurement
656
657                                def lipidAssayInstance = new dbnp.clinicaldata.ClinicalAssayInstance(
658                                        assay: lipidAssay
659                                ).with { if (!validate()) { errors.each { println it} } else save()}
660
661                                humanStudy.samples*.each {
662                                        new dbnp.clinicaldata.ClinicalFloatData(
663                                                assay: lipidAssayInstance,
664                                                measurement: ldlMeasurement,
665                                                sample: it.name,
666                                                value: Math.round(Math.random()*ldlMeasurement.detectableLimit)
667                                        ).with { if (!validate()) { errors.each { println it} } else save()}
668
669                                        new dbnp.clinicaldata.ClinicalFloatData(
670                                                assay: lipidAssayInstance,
671                                                measurement: hdlMeasurement,
672                                                sample: it.name,
673                                                value: Math.round(Math.random()*hdlMeasurement.detectableLimit)
674                                        ).with { if (!validate()) { errors.each { println it} } else save()}
675                                }
676                                */
677                                // Add assay to study capture module
678
679                                def clinicalModule = new AssayModule(
680                                        name: 'Clinical data',
681                                        type: AssayType.CLINICAL_DATA,
682                                        platform: 'clinical measurements',
683                                        url: 'http://localhost:8080/gscf'
684                                ).with { if (!validate()) { errors.each { println it} } else save()}
685
686                                def lipidAssayRef = new Assay(
687                                        name: 'Lipid profiling',
688                                        module: clinicalModule,
689                                        externalAssayId: 0
690                                ).with { if (!validate()) { errors.each { println it} } else save()}
691
692                                humanStudy.samples*.each {
693                                        lipidAssayRef.addToSamples(it)
694                                }
695                                lipidAssayRef.save()
696
697                                humanStudy.addToAssays(lipidAssayRef);
698                                humanStudy.save()
699                               
700                        }
701                }
702        }
703
704        def destroy = {
705        }
706} 
Note: See TracBrowser for help on using the repository browser.