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

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

Updated the fields of person to contain title, gender, prefix and mobile phone. Also updated the views so that the pagination buttons appear beneath the 'add new' button.

  • Property svn:keywords set to Author Rev Date
File size: 32.5 KB
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: 382 $
13 * $Author: roberth $
14 * $Date: 2010-04-26 14:53:36 +0000 (ma, 26 apr 2010) $
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                        println ".adding event templates..."
418                        def dietTreatmentTemplate = new Template(
419                                name: 'Diet treatment ', entity: dbnp.studycapturing.Event)
420                        .addToFields(sampleDescriptionField)
421                        .addToFields(new TemplateField(
422                                name: 'Diet', type: TemplateFieldType.STRINGLIST,
423                                listEntries: [new TemplateFieldListItem(name:'10% fat (palm oil)'),new TemplateFieldListItem(name: '45% fat (palm oil)')]))
424                        .with { if (!validate()) { errors.each { println it} } else save()}
425
426                        def boostTreatmentTemplate = new Template(
427                                name: 'Boost treatment ', entity: dbnp.studycapturing.Event)
428                        .addToFields(sampleDescriptionField)
429                        .addToFields(new TemplateField(
430                                name: 'Compound', type: TemplateFieldType.STRING,
431                                listEntries: [new TemplateFieldListItem(name:'Vehicle'),new TemplateFieldListItem(name: 'Leptin')]))
432                        .with { if (!validate()) { errors.each { println it} } else save()}
433
434                        /*
435                        //events
436                        def eventDiet = new EventDescription(
437                                name: 'Diet treatment',
438                                description: 'Diet treatment (fat percentage)',
439                                classification: treatmentTerm,
440                                protocol: dietProtocol,
441                                isSamplingEvent: false
442                        ).with { if (!validate()) { errors.each { println it} } else save()}
443
444                        def eventBoost = new EventDescription(
445                                name: 'Boost treatment',
446                                description: 'Boost treatment (leptin or vehicle)',
447                                classification: treatmentTerm,
448                                protocol: boostProtocol,
449                                isSamplingEvent: false
450                        ).with { if (!validate()) { errors.each { println it} } else save()}
451
452                        def samplingEvent = new EventDescription(
453                                name: 'Liver extraction',
454                                description: 'Liver sampling for transcriptomics arrays',
455                                protocol: liverSamplingProtocol,
456                                isSamplingEvent: true
457                        ).with { if (!validate()) { errors.each { println it} } else save()}
458
459                        def bloodSamplingEventDescription = new EventDescription(
460                                name: 'Blood extraction',
461                                description: 'Blood extraction targeted at lipid assays',
462                                protocol: bloodSamplingProtocol,
463                                isSamplingEvent: true
464                        ).with { if (!validate()) { errors.each { println it} } else save()}
465
466
467            def fastingTreatment = new EventDescription(
468                                name: 'Fasting treatment',
469                                description: 'Fasting Protocol NuGO PPSH',
470                                protocol: fastingProtocol,
471                                isSamplingEvent: false
472                        ).with { if (!validate()) { errors.each { println it} } else save()}
473
474                        println('Adding PPS3 study...')
475                        */
476                        // studies
477                        println ".adding NuGO PPS3 leptin example study..."
478                        def exampleStudy = new Study(
479                                template: studyTemplate,
480                                title:"NuGO PPS3 mouse study leptin module",
481                                code:"PPS3_leptin_module",
482                                researchQuestion:"Leptin etc.",
483                                ecCode:"2007117.c",
484                                startDate: Date.parse('yyyy-MM-dd','2007-12-11')
485                        )
486                        .with { if (!validate()) { errors.each { println it} } else save()}
487
488                        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." )
489                        exampleStudy.save()
490
491                        println ".adding NuGO PPSH example study..."
492                        def exampleHumanStudy = new Study(
493                                template: studyTemplate,
494                                title:"Human example template",
495                                code:"Human example code",
496                                researchQuestion:"Leptin etc.",
497                                ecCode:"2007117.c",
498                                startDate: Date.parse('yyyy-MM-dd','2007-12-11')
499                        )
500                        .with { if (!validate()) { errors.each { println it} } else save()}
501
502                        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." )
503                        exampleHumanStudy.save()
504
505                        def evLF = new Event(
506                                startTime: Date.parse('yyyy-MM-dd','2008-01-07'),
507                                endTime: Date.parse('yyyy-MM-dd','2008-01-14'),
508                                template: dietTreatmentTemplate
509                        )
510                        .with { if (!validate()) { errors.each { println it} } else save()}
511                        evLF.setFieldValue( 'Diet','10% fat (palm oil)' )
512                        evLF.save(flush:true)
513                        // TODO: find out why Diet is not set and Compound is
514
515                        def evHF = new Event(
516                                startTime: Date.parse('yyyy-MM-dd','2008-01-07'),
517                                endTime: Date.parse('yyyy-MM-dd','2008-01-14'),
518                                template: dietTreatmentTemplate
519                        )
520                        .setFieldValue( 'Diet','45% fat (palm oil)' )
521                        .with { if (!validate()) { errors.each { println it} } else save()}
522
523                        def evBV = new Event(
524                                startTime: Date.parse('yyyy-MM-dd','2008-01-07'),
525                                endTime: Date.parse('yyyy-MM-dd','2008-01-14'),
526                                template: boostTreatmentTemplate
527                        )
528                        .setFieldValue( 'Compound','Vehicle' )
529                        .with { if (!validate()) { errors.each { println it} } else save()}
530
531                        def evBL = new Event(
532                                startTime: Date.parse('yyyy-MM-dd','2008-01-07'),
533                                endTime: Date.parse('yyyy-MM-dd','2008-01-14'),
534                                template: boostTreatmentTemplate
535                        )
536                        .setFieldValue( 'Compound','Leptin' )
537                        .with { if (!validate()) { errors.each { println it} } else save()}
538
539                        /*
540                        def evLF4 = new Event(
541                                startTime: Date.parse('yyyy-MM-dd','2008-01-07'),
542                                endTime: Date.parse('yyyy-MM-dd','2008-02-04'),
543                                eventDescription: eventDiet,
544                                parameterStringValues: ['Diet':'10% fat (palm oil)']
545                        ).with { if (!validate()) { errors.each { println it} } else save()}
546
547                        def evHF4 = new Event(
548                                startTime: Date.parse('yyyy-MM-dd','2008-01-07'),
549                                endTime: Date.parse('yyyy-MM-dd','2008-02-04'),
550                                eventDescription: eventDiet,
551                                parameterStringValues: ['Diet':'45% fat (palm oil)']
552                        ).with { if (!validate()) { errors.each { println it} } else save()}
553
554                        def evBV4 = new Event(
555                                startTime: Date.parse('yyyy-MM-dd','2008-01-07'),
556                                endTime: Date.parse('yyyy-MM-dd','2008-02-04'),
557                                eventDescription: eventBoost,
558                                parameterStringValues: ['Compound':'Vehicle']
559                        ).with { if (!validate()) { errors.each { println it} } else save()}
560
561                        def evBL4 = new Event(
562                                startTime: Date.parse('yyyy-MM-dd','2008-01-07'),
563                                endTime: Date.parse('yyyy-MM-dd','2008-02-04'),
564                                eventDescription: eventBoost,
565                                parameterStringValues: ['Compound':'Leptin']
566                        ).with { if (!validate()) { errors.each { println it} } else save()}
567
568                        def evS = new SamplingEvent(
569                                        startTime: Date.parse('yyyy-MM-dd','2008-01-14'),
570                                        endTime: Date.parse('yyyy-MM-dd','2008-01-14'),
571                                        eventDescription: samplingEvent,
572                                        parameterFloatValues: ['Sample weight':5F]
573                        ).with { if (!validate()) { errors.each { println it} } else save()}
574
575                        def evS4 = new SamplingEvent(
576                                        startTime: Date.parse('yyyy-MM-dd','2008-02-04'),
577                                        endTime: Date.parse('yyyy-MM-dd','2008-02-04'),
578                                        eventDescription: samplingEvent,
579                                        parameterFloatValues: ['Sample weight':5F]
580                        ).with { if (!validate()) { errors.each { println it} } else save()}
581                        */
582
583                        // Add events to study
584                        exampleStudy
585                        .addToEvents(evLF)
586                        .addToEvents(evHF)
587                        .addToEvents(evBV)
588                        .addToEvents(evBL)
589                        /*
590                        .addToEvents(evLF4)
591                        .addToEvents(evHF4)
592                        .addToEvents(evBV4)
593                        .addToEvents(evBL4)
594                        .addToSamplingEvents(evS)
595                        .addToSamplingEvents(evS4)
596                        */
597                        .save()
598
599                        def LFBV1 = new EventGroup(name:"10% fat + vehicle for 1 week")
600                        .addToEvents(evLF)
601                        .addToEvents(evBV)
602                        .with { if (!validate()) { errors.each { println it} } else save()}
603
604                        def LFBL1 = new EventGroup(name:"10% fat + leptin for 1 week")
605                        .addToEvents(evLF)
606                        .addToEvents(evBL)
607                        .with { if (!validate()) { errors.each { println it} } else save()}
608
609                        def HFBV1 = new EventGroup(name:"45% fat + vehicle for 1 week")
610                        .addToEvents(evHF)
611                        .addToEvents(evBV)
612                        .with { if (!validate()) { errors.each { println it} } else save()}
613
614                        def HFBL1 = new EventGroup(name:"45% fat + leptin for 1 week")
615                        .addToEvents(evHF)
616                        .addToEvents(evBL)
617                        .with { if (!validate()) { errors.each { println it} } else save()}
618
619                        /*
620                        def LFBV4 = new EventGroup(name:"10% fat + vehicle for 4 weeks")
621                        .addToEvents(evLF4)
622                        .addToEvents(evBV4)
623                        .with { if (!validate()) { errors.each { println it} } else save()}
624
625                        def LFBL4 = new EventGroup(name:"10% fat + leptin for 4 weeks")
626                        .addToEvents(evLF4)
627                        .addToEvents(evBL4)
628                        .with { if (!validate()) { errors.each { println it} } else save()}
629
630                        def HFBV4 = new EventGroup(name:"45% fat + vehicle for 4 weeks")
631                        .addToEvents(evHF4)
632                        .addToEvents(evBV4)
633                        .with { if (!validate()) { errors.each { println it} } else save()}
634
635                        def HFBL4 = new EventGroup(name:"45% fat + leptin for 4 weeks")
636                        .addToEvents(evHF4)
637                        .addToEvents(evBL4)
638                        .with { if (!validate()) { errors.each { println it} } else save()}
639                        */
640
641            // Add subjects and samples and compose EventGroups
642
643                        def x=1
644                        40.times {
645                                def currentSubject = new Subject(
646                                        name: "A" + x++,
647                                        species: mouseTerm,
648                                        template: mouseTemplate,
649                                )
650                                .setFieldValue("Gender", "Male")
651                                //.setFieldValue("Genotype", c57bl6Term)
652                                .setFieldValue("Age (weeks)", 17)
653                                .setFieldValue("Cage", "" + (int)(x/2))
654                                .with { if (!validate()) { errors.each { println it} } else save(flush:true)}
655
656                                exampleStudy.addToSubjects(currentSubject)
657                                .with { if (!validate()) { errors.each { println it} } else save()}
658
659                                // Add subject to appropriate EventGroup
660                                /*
661                                if (x > 70) { HFBL4.addToSubjects(currentSubject).save() }
662                                else if (x > 60) { HFBV4.addToSubjects(currentSubject).save() }
663                                else if (x > 50) { LFBL4.addToSubjects(currentSubject).save() }
664                                else if (x > 40) { LFBV4.addToSubjects(currentSubject).save() }
665                                else if (x > 30) { HFBL1.addToSubjects(currentSubject).save() }
666                                else if (x > 20) { HFBV1.addToSubjects(currentSubject).save() }
667                                else if (x > 10) { LFBL1.addToSubjects(currentSubject).save() }
668                                else             { LFBV1.addToSubjects(currentSubject).save() }
669                                */
670
671                                if (x > 30) { HFBL1.addToSubjects(currentSubject).save() }
672                                else if (x > 20) { HFBV1.addToSubjects(currentSubject).save() }
673                                else if (x > 10) { LFBL1.addToSubjects(currentSubject).save() }
674                                else             { LFBV1.addToSubjects(currentSubject).save() }
675
676                        }
677
678                        // Add EventGroups to study
679                        exampleStudy
680                        .addToEventGroups(LFBV1)
681                        .addToEventGroups(LFBL1)
682                        .addToEventGroups(HFBV1)
683                        .addToEventGroups(HFBL1)
684                        //.addToEventGroups(LFBV4)
685                        //.addToEventGroups(LFBL4)
686                        //.addToEventGroups(HFBV4)
687                        //.addToEventGroups(HFBL4)
688
689                        // Add persons to study
690                        def studyperson1 = new StudyPerson( person: person1, role: role1 ).save();
691                        def studyperson2 = new StudyPerson( person: person2, role: role2 ).save();
692
693                        exampleStudy
694                        .addToPersons( studyperson1 )
695                        .addToPersons( studyperson2 )
696                        .save()
697                       
698                        /*
699                        println 'Adding PPSH study'
700
701                        def humanStudy = new Study(
702                                template: studyTemplate,
703                                title:"NuGO PPS human study",
704                                code:"PPSH",
705                                researchQuestion:"How much are fasting plasma and urine metabolite levels affected by prolonged fasting ?",
706                                description:"Human study",
707                                ecCode:"unknown",
708                                startDate: Date.parse('yyyy-MM-dd','2009-01-01')
709                        ).with { if (!validate()) { errors.each { println it} } else save()}
710
711                        def fastingEvent = new Event(
712                                        startTime: Date.parse('yyyy-MM-dd','2008-01-14'),
713                                        endTime: Date.parse('yyyy-MM-dd','2008-01-14'),
714                                        eventDescription: fastingTreatment,
715                                        parameterStringValues: ['Fasting period':'8h']);
716
717                        def bloodSamplingEvent = new SamplingEvent(
718                                        startTime: Date.parse('yyyy-MM-dd','2008-01-14'),
719                                        endTime: Date.parse('yyyy-MM-dd','2008-01-14'),
720                                        eventDescription: bloodSamplingEventDescription,
721                                        parameterFloatValues: ['Sample volume':4.5F]);
722
723                        def rootGroup = new EventGroup(name: 'Root group');
724                        rootGroup.addToEvents fastingEvent
725                        rootGroup.addToEvents bloodSamplingEvent
726                        rootGroup.save()
727
728            def y = 1
729            11.times {
730              def currentSubject = new Subject(
731                      name: "" + y++,
732                      species: humanTerm,
733                      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()}
734
735              rootGroup.addToSubjects currentSubject
736              rootGroup.save()
737
738              def currentSample = new Sample(
739                      name: currentSubject.name + '_B',
740                      material: bloodTerm,
741                      parentSubject: currentSubject,
742                      parentEvent: bloodSamplingEvent);
743
744
745              humanStudy.addToSubjects(currentSubject).addToSamples(currentSample).with { if (!validate()) { errors.each { println it} } else save()}
746          }
747
748          humanStudy.addToEvents(fastingEvent)
749          humanStudy.addToSamplingEvents(bloodSamplingEvent)
750          humanStudy.addToEventGroups rootGroup
751          humanStudy.save()
752
753                        // Add clinical data
754
755                        def lipidAssay = new dbnp.clinicaldata.ClinicalAssay(
756                                name: 'Lipid profile',
757                                approved: true
758                        ).with { if (!validate()) { errors.each { println it} } else save()}
759
760                        def ldlMeasurement = new dbnp.clinicaldata.ClinicalMeasurement(
761                                name: 'LDL',
762                                unit: 'mg/dL',
763                                type: dbnp.data.FeatureType.QUANTITATIVE,
764                                referenceValues: '100 mg/dL',
765                                detectableLimit: 250,
766                                isDrug: false, isIntake: true, inSerum: true
767                        ).with { if (!validate()) { errors.each { println it} } else save()}
768
769                        def hdlMeasurement = new dbnp.clinicaldata.ClinicalMeasurement(
770                                name: 'HDL',
771                                unit: 'mg/dL',
772                                type: dbnp.data.FeatureType.QUANTITATIVE,
773                                referenceValues: '50 mg/dL',
774                                detectableLimit: 100,
775                                isDrug: false, isIntake: true, inSerum: true
776                        ).with { if (!validate()) { errors.each { println it} } else save()}
777
778                        lipidAssay.addToMeasurements ldlMeasurement
779                        lipidAssay.addToMeasurements hdlMeasurement
780
781                        def lipidAssayInstance = new dbnp.clinicaldata.ClinicalAssayInstance(
782                                assay: lipidAssay
783                        ).with { if (!validate()) { errors.each { println it} } else save()}
784
785                        humanStudy.samples*.each {
786                                new dbnp.clinicaldata.ClinicalFloatData(
787                                        assay: lipidAssayInstance,
788                                        measurement: ldlMeasurement,
789                                        sample: it.name,
790                                        value: Math.round(Math.random()*ldlMeasurement.detectableLimit)
791                                ).with { if (!validate()) { errors.each { println it} } else save()}
792
793                                new dbnp.clinicaldata.ClinicalFloatData(
794                                        assay: lipidAssayInstance,
795                                        measurement: hdlMeasurement,
796                                        sample: it.name,
797                                        value: Math.round(Math.random()*hdlMeasurement.detectableLimit)
798                                ).with { if (!validate()) { errors.each { println it} } else save()}
799                        }
800
801                        // Add assay to study capture module
802
803                        def clinicalModule = new AssayModule(
804                                name: 'Clinical data',
805                                type: AssayType.CLINICAL_DATA,
806                                platform: 'clinical measurements',
807                                url: 'http://localhost:8080/gscf'
808                        ).with { if (!validate()) { errors.each { println it} } else save()}
809
810                        def lipidAssayRef = new Assay(
811                                name: 'Lipid profiling',
812                                module: clinicalModule,
813                                externalAssayId: lipidAssayInstance.id
814                        ).with { if (!validate()) { errors.each { println it} } else save()}
815
816                        humanStudy.samples*.each {
817                                lipidAssayRef.addToSamples(it)
818                        }
819                        lipidAssayRef.save()
820
821                        humanStudy.addToAssays(lipidAssayRef);
822                        humanStudy.save()
823*/
824                }
825        }
826
827        def destroy = {
828        }
829} 
Note: See TracBrowser for help on using the repository browser.