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

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

Reverting Subject optimization as it breaks the study create wizard on adding Subjects, added help texts to Bootstrap and icons to study create wizard, added new text to home, added help texts to study create wizard pages

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