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

Last change on this file since 513 was 513, checked in by keesvb, 9 years ago

version 0.2.3, deleted sampleTemplates field in Template as it will not be used for now

  • Property svn:keywords set to Author Rev Date
File size: 31.0 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: 513 $
14 * $Author: keesvb $
15 * $Date: 2010-06-03 06:12:06 +0000 (do, 03 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                        .addToFields(new TemplateField(
358                                name: 'Fasting period',
359                                type: TemplateFieldType.STRING))
360                         .with { if (!validate()) { errors.each { println it} } else save()}
361
362                        // SamplingEvent templates
363
364                        def samplingProtocolField = new TemplateField(
365                        name: 'SampleProtocol',type: TemplateFieldType.STRING)
366                        .with { if (!validate()) { errors.each { println it} } else save()}
367
368                        def liverSamplingEventTemplate = new Template(
369                                name: 'Liver extraction',
370                                description: 'Liver sampling for transcriptomics arrays',
371                                entity: dbnp.studycapturing.SamplingEvent)
372                        .addToFields(samplingProtocolField)
373                        .addToFields(new TemplateField(
374                                name: 'Sample weight',
375                                unit: 'mg',
376                                type: TemplateFieldType.FLOAT))
377                        .with { if (!validate()) { errors.each { println it} } else save()}
378
379                        def bloodSamplingEventTemplate = new Template(
380                                name: 'Blood extraction',
381                                description: 'Blood extraction targeted at lipid assays',
382                                entity: dbnp.studycapturing.SamplingEvent)
383                        .addToFields(samplingProtocolField)
384                        .addToFields(new TemplateField(
385                                name: 'Sample volume',
386                                unit: 'ml',
387                                type: TemplateFieldType.FLOAT))
388                        .with { if (!validate()) { errors.each { println it} } else save()}
389
390
391                        // Add example studies
392                        if (!(grails.util.GrailsUtil.environment == GrailsApplication.ENV_TEST)) {
393                                println ".adding NuGO PPS3 leptin example study..."
394                                def mouseStudy = new Study(
395                                        template: studyTemplate,
396                                        title:"NuGO PPS3 mouse study leptin module",
397                                        code:"PPS3_leptin_module",
398                                        researchQuestion:"Leptin etc.",
399                                        ecCode:"2007117.c",
400                                        startDate: Date.parse('yyyy-MM-dd','2008-01-02')
401                                )
402                                .with { if (!validate()) { errors.each { println it} } else save()}
403
404                                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." )
405                                mouseStudy.save()
406
407                                def evLF = new Event(
408                                        startTime: 3600,
409                                        endTime: 3600 +7 * 24 * 3600,
410                                        template: dietTreatmentTemplate
411                                )
412                                .setFieldValue( 'Diet','10% fat (palm oil)')
413                                .with { if (!validate()) { errors.each { println it} } else save()}
414
415                                def evHF = new Event(
416                                        startTime: 3600,
417                                        endTime: 3600 +7 * 24 * 3600,
418                                        template: dietTreatmentTemplate
419                                )
420                                .setFieldValue( 'Diet','45% fat (palm oil)' )
421                                .with { if (!validate()) { errors.each { println it} } else save()}
422
423                                def evBV = new Event(
424                                        startTime: 3600,
425                                        endTime: 3600 +7 * 24 * 3600,
426                                        template: boostTreatmentTemplate
427                                )
428                                .setFieldValue( 'Compound','Vehicle' )
429                                .with { if (!validate()) { errors.each { println it} } else save()}
430
431                                def evBL = new Event(
432                                        startTime: 3600,
433                                        endTime: 3600 +7 * 24 * 3600,
434                                        template: boostTreatmentTemplate
435                                )
436                                .setFieldValue( 'Compound','Leptin' )
437                                .with { if (!validate()) { errors.each { println it} } else save()}
438
439                                def evLF4 = new Event(
440                                        startTime: 3600,
441                                        endTime: 3600 + 4 * 7 * 24 * 3600,
442                                        template: dietTreatmentTemplate
443                                )
444                                .setFieldValue( 'Diet','10% fat (palm oil)')
445                                .with { if (!validate()) { errors.each { println it} } else save()}
446
447                                def evHF4 = new Event(
448                                        startTime: 3600,
449                                        endTime: 3600 + 4 * 7 * 24 * 3600,
450                                        template: dietTreatmentTemplate
451                                )
452                                .setFieldValue( 'Diet','45% fat (palm oil)' )
453                                .with { if (!validate()) { errors.each { println it} } else save()}
454
455                                def evBV4 = new Event(
456                                        startTime: 3600,
457                                        endTime: 3600 + 4 * 7 * 24 * 3600,
458                                        template: boostTreatmentTemplate
459                                )
460                                .setFieldValue( 'Compound','Vehicle' )
461                                .with { if (!validate()) { errors.each { println it} } else save()}
462
463                                def evBL4 = new Event(
464                                        startTime: 3600,
465                                        endTime: 3600 + 4 * 7 * 24 * 3600,
466                                        template: boostTreatmentTemplate
467                                )
468                                .setFieldValue( 'Compound','Leptin' )
469                                .with { if (!validate()) { errors.each { println it} } else save()}
470
471                                def evS = new SamplingEvent(
472                                        startTime: 3600 +7 * 24 * 3600,
473                                        endTime: 3600 +7 * 24 * 3600,
474                                        template: liverSamplingEventTemplate)
475                                .setFieldValue('Sample weight',5F)
476                                .with { if (!validate()) { errors.each { println it} } else save()}
477
478                                def evS4 = new SamplingEvent(
479                                        startTime: 3600 +7 * 24 * 3600,
480                                        endTime: 3600 +7 * 24 * 3600,
481                                        template: liverSamplingEventTemplate)
482                                .setFieldValue('Sample weight',5F)
483                                .with { if (!validate()) { errors.each { println it} } else save()}
484
485                                // Add events to study
486                                mouseStudy
487                                .addToEvents(evLF)
488                                .addToEvents(evHF)
489                                .addToEvents(evBV)
490                                .addToEvents(evBL)
491                                .addToEvents(evLF4)
492                                .addToEvents(evHF4)
493                                .addToEvents(evBV4)
494                                .addToEvents(evBL4)
495                                .addToSamplingEvents(evS)
496                                .addToSamplingEvents(evS4)
497                                .save()
498
499                                def LFBV1 = new EventGroup(name:"10% fat + vehicle for 1 week")
500                                .addToEvents(evLF)
501                                .addToEvents(evBV)
502                                .addToEvents(evS)
503                                .with { if (!validate()) { errors.each { println it} } else save()}
504
505                                def LFBL1 = new EventGroup(name:"10% fat + leptin for 1 week")
506                                .addToEvents(evLF)
507                                .addToEvents(evBL)
508                                .addToEvents(evS)
509                                .with { if (!validate()) { errors.each { println it} } else save()}
510
511                                def HFBV1 = new EventGroup(name:"45% fat + vehicle for 1 week")
512                                .addToEvents(evHF)
513                                .addToEvents(evBV)
514                                .addToEvents(evS)
515                                .with { if (!validate()) { errors.each { println it} } else save()}
516
517                                def HFBL1 = new EventGroup(name:"45% fat + leptin for 1 week")
518                                .addToEvents(evHF)
519                                .addToEvents(evBL)
520                                .addToEvents(evS)
521                                .with { if (!validate()) { errors.each { println it} } else save()}
522
523                                def LFBV4 = new EventGroup(name:"10% fat + vehicle for 4 weeks")
524                                .addToEvents(evLF4)
525                                .addToEvents(evBV4)
526                                .addToEvents(evS4)
527                                .with { if (!validate()) { errors.each { println it} } else save()}
528
529                                def LFBL4 = new EventGroup(name:"10% fat + leptin for 4 weeks")
530                                .addToEvents(evLF4)
531                                .addToEvents(evBL4)
532                                .addToEvents(evS4)
533                                .with { if (!validate()) { errors.each { println it} } else save()}
534
535                                def HFBV4 = new EventGroup(name:"45% fat + vehicle for 4 weeks")
536                                .addToEvents(evHF4)
537                                .addToEvents(evBV4)
538                                .addToEvents(evS4)
539                                .with { if (!validate()) { errors.each { println it} } else save()}
540
541                                def HFBL4 = new EventGroup(name:"45% fat + leptin for 4 weeks")
542                                .addToEvents(evHF4)
543                                .addToEvents(evBL4)
544                                .addToEvents(evS4)
545                                .with { if (!validate()) { errors.each { println it} } else save()}
546
547                // Add subjects and samples and compose EventGroups
548                                def x=1
549                                20.times {
550                                        def currentSubject = new Subject(
551                                                name: "A" + x++,
552                                                species: mouseTerm,
553                                                template: mouseTemplate,
554                                        )
555                                        .setFieldValue("Gender", "Male")
556                                        .setFieldValue("Genotype", c57bl6Term)
557                                        .setFieldValue("Age", 17)
558                                        .setFieldValue("Cage", "" + (int)(x/2))
559                                        .with { if (!validate()) { errors.each { println it} } else save(flush:true)}
560
561                                        mouseStudy.addToSubjects(currentSubject)
562                                        .with { if (!validate()) { errors.each { println it} } else save()}
563
564                                        // Add subject to appropriate EventGroup
565                                        if (x > 70) { HFBL4.addToSubjects(currentSubject).save() }
566                                        else if (x > 60) { HFBV4.addToSubjects(currentSubject).save() }
567                                        else if (x > 50) { LFBL4.addToSubjects(currentSubject).save() }
568                                        else if (x > 40) { LFBV4.addToSubjects(currentSubject).save() }
569                                        else if (x > 30) { HFBL1.addToSubjects(currentSubject).save() }
570                                        else if (x > 20) { HFBV1.addToSubjects(currentSubject).save() }
571                                        else if (x > 10) { LFBL1.addToSubjects(currentSubject).save() }
572                                        else             { LFBV1.addToSubjects(currentSubject).save() }
573
574                                }
575
576                                // Add EventGroups to study
577                                mouseStudy
578                                .addToEventGroups(LFBV1)
579                                .addToEventGroups(LFBL1)
580                                .addToEventGroups(HFBV1)
581                                .addToEventGroups(HFBL1)
582                                .addToEventGroups(LFBV4)
583                                .addToEventGroups(LFBL4)
584                                .addToEventGroups(HFBV4)
585                                .addToEventGroups(HFBL4)
586
587                                // Add persons and publications to study
588                                def studyperson1 = new StudyPerson( person: person1, role: role1 ).save();
589                                def studyperson2 = new StudyPerson( person: person2, role: role2 ).save();
590
591                                mouseStudy
592                                .addToPersons( studyperson1 )
593                                .addToPersons( studyperson2 )
594                                .addToPublications( publication1 )
595                                .addToPublications( publication2 )
596                                .save()
597
598                                println ".adding NuGO PPSH example study..."
599
600                                def humanStudy = new Study(
601                                        template: studyTemplate,
602                                        title:"NuGO PPS human study",
603                                        code:"PPSH",
604                                        researchQuestion:"How much are fasting plasma and urine metabolite levels affected by prolonged fasting ?",
605                                        description:"Human study",
606                                        ecCode:"unknown",
607                                        startDate: Date.parse('yyyy-MM-dd','2008-01-14'))
608                                .setFieldValue( 'Description', "Human study performed at RRI; centres involved: RRI, IFR, TUM, Maastricht U." )
609                                .with { if (!validate()) { errors.each { println it} } else save()}
610
611                                def rootGroup = new EventGroup(name: 'Root group');
612
613                                def fastingEvent = new Event(
614                                        startTime: 3 * 24 * 3600 + 22 * 3600,
615                                        endTime: 3 * 24 * 3600 + 30 * 3600,
616                                        template: fastingTreatment)
617                                .setFieldValue('Fasting period','8h');
618
619
620                                def bloodSamplingEvent = new SamplingEvent(
621                                        startTime: 3 * 24 * 3600 + 30 * 3600,
622                                        endTime: 3 * 24 * 3600 + 30 * 3600,
623                                        template: bloodSamplingEventTemplate)
624                                .setFieldValue('Sample volume',4.5F);
625
626                                rootGroup.addToEvents fastingEvent
627                                rootGroup.addToEvents bloodSamplingEvent
628                                rootGroup.save()
629
630                                def y = 1
631                                11.times {
632                                        def currentSubject = new Subject(
633                                              name: "" + y++,
634                                              species: humanTerm,
635                                              template: humanTemplate)
636                                        .setFieldValue("Gender", (Math.random() > 0.5) ? "Male" : "Female")
637                                        .setFieldValue("DOB", new java.text.SimpleDateFormat("dd-mm-yy").parse("01-02-19" + (10 + (int) (Math.random() * 80))))
638                                        .setFieldValue("Age", 30)
639                                        .setFieldValue("Height", Math.random() * 2F)
640                                        .setFieldValue("Weight", Math.random() * 150F)
641                                        .setFieldValue("BMI", 20 + Math.random() * 10F)
642                                        .with { if (!validate()) { errors.each { println it} } else save()}
643
644                                        rootGroup.addToSubjects currentSubject
645                                        rootGroup.save()
646
647                                        def currentSample = new Sample(
648                                              name: currentSubject.name + '_B',
649                                              material: bloodTerm,
650                                              parentSubject: currentSubject,
651                                              parentEvent: bloodSamplingEvent);
652
653                                        humanStudy.addToSubjects(currentSubject).addToSamples(currentSample).with { if (!validate()) { errors.each { println it} } else save()}
654                                }
655
656                                humanStudy.addToEvents(fastingEvent)
657                                humanStudy.addToSamplingEvents(bloodSamplingEvent)
658                                humanStudy.addToEventGroups rootGroup
659
660
661                                // Add persons to study
662                                def studyperson3 = new StudyPerson( person: person1, role: role2 ).save();
663
664                                humanStudy
665                                .addToPersons( studyperson3 )
666                                .addToPublications( publication2 )
667                                .save()
668
669                                /*
670                                // Add clinical data
671
672                                def lipidAssay = new dbnp.clinicaldata.ClinicalAssay(
673                                        name: 'Lipid profile',
674                                        approved: true
675                                ).with { if (!validate()) { errors.each { println it} } else save()}
676
677                                def ldlMeasurement = new dbnp.clinicaldata.ClinicalMeasurement(
678                                        name: 'LDL',
679                                        unit: 'mg/dL',
680                                        type: dbnp.data.FeatureType.QUANTITATIVE,
681                                        referenceValues: '100 mg/dL',
682                                        detectableLimit: 250,
683                                        isDrug: false, isIntake: true, inSerum: true
684                                ).with { if (!validate()) { errors.each { println it} } else save()}
685
686                                def hdlMeasurement = new dbnp.clinicaldata.ClinicalMeasurement(
687                                        name: 'HDL',
688                                        unit: 'mg/dL',
689                                        type: dbnp.data.FeatureType.QUANTITATIVE,
690                                        referenceValues: '50 mg/dL',
691                                        detectableLimit: 100,
692                                        isDrug: false, isIntake: true, inSerum: true
693                                ).with { if (!validate()) { errors.each { println it} } else save()}
694
695                                lipidAssay.addToMeasurements ldlMeasurement
696                                lipidAssay.addToMeasurements hdlMeasurement
697
698                                def lipidAssayInstance = new dbnp.clinicaldata.ClinicalAssayInstance(
699                                        assay: lipidAssay
700                                ).with { if (!validate()) { errors.each { println it} } else save()}
701
702                                humanStudy.samples*.each {
703                                        new dbnp.clinicaldata.ClinicalFloatData(
704                                                assay: lipidAssayInstance,
705                                                measurement: ldlMeasurement,
706                                                sample: it.name,
707                                                value: Math.round(Math.random()*ldlMeasurement.detectableLimit)
708                                        ).with { if (!validate()) { errors.each { println it} } else save()}
709
710                                        new dbnp.clinicaldata.ClinicalFloatData(
711                                                assay: lipidAssayInstance,
712                                                measurement: hdlMeasurement,
713                                                sample: it.name,
714                                                value: Math.round(Math.random()*hdlMeasurement.detectableLimit)
715                                        ).with { if (!validate()) { errors.each { println it} } else save()}
716                                }
717                                */
718                                // Add assay to study capture module
719
720                                def clinicalModule = new AssayModule(
721                                        name: 'Clinical data',
722                                        type: AssayType.CLINICAL_DATA,
723                                        platform: 'clinical measurements',
724                                        url: 'http://localhost:8080/gscf'
725                                ).with { if (!validate()) { errors.each { println it} } else save()}
726
727                                def lipidAssayRef = new Assay(
728                                        name: 'Lipid profiling',
729                                        module: clinicalModule,
730                                        externalAssayId: 0
731                                ).with { if (!validate()) { errors.each { println it} } else save()}
732
733                                humanStudy.samples*.each {
734                                        lipidAssayRef.addToSamples(it)
735                                }
736                                lipidAssayRef.save()
737
738                                humanStudy.addToAssays(lipidAssayRef);
739                                humanStudy.save()
740
741                                mouseStudy.addToAssays(lipidAssayRef);
742                                mouseStudy.save()
743
744                        }
745                }
746
747                // Ontologies must be connected to the templatefields in runtime
748                // because the Ontology.findByNcboId is not available otherwise
749                TemplateEntity.getField( Subject.domainFields, 'species' ).ontologies = [Ontology.findByNcboId(1132)]
750                TemplateEntity.getField( Sample.domainFields, 'material' ).ontologies = [Ontology.findByNcboId(1005)]
751
752        }
753
754        def destroy = {
755        }
756} 
Note: See TracBrowser for help on using the repository browser.