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

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