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

Last change on this file since 530 was 530, checked in by gajula, 10 years ago

plant templates-prasad

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