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

Last change on this file since 536 was 536, checked in by roberth, 11 years ago

Samples are now shown in the study overview page. Also some tests are added and the bootstrap is updated to show some sample fields with a template

  • Property svn:keywords set to Author Rev Date
File size: 39.9 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: 536 $
14 * $Author: roberth $
15 * $Date: 2010-06-07 07:20:00 +0000 (ma, 07 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                        )
204                .with { if (!validate()) { errors.each { println it} } else save()}
205
206
207                // Nutritional study template
208                        println ".adding academic study template..."
209                        def studyTemplate = new Template(
210                                name: 'Academic study',
211                                entity: dbnp.studycapturing.Study
212                        )
213                        .addToFields(new TemplateField(name: 'Description',type: TemplateFieldType.TEXT,comment:'Describe here the type of subjects and the treatment, challenges and sampling.'))
214                        .addToFields(new TemplateField(
215                                name: 'Study code',
216                                type: TemplateFieldType.STRING,
217                                preferredIdentifier:true,
218                                comment: 'Fill out the code by which many people will recognize your study')
219                        )
220                        .addToFields(new TemplateField(name: 'Objectives',type: TemplateFieldType.TEXT,comment:'Fill out the aim or questions of the study'))
221                        .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'))
222                        .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)'))
223                        //.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.'))
224                        .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)'))
225                        .addToFields(new TemplateField(name: 'Lab id',type: TemplateFieldType.STRING,comment:'In which lab was the study performed; indicate the roomnumber.'))
226                        .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?)'))
227                        //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'))
228                        .with { if (!validate()) { errors.each { println it} } else save()}
229
230                        // Mouse template
231                        println ".adding mouse subject template..."
232                        def mouseTemplate = new Template(
233                                name: 'Mouse', entity: dbnp.studycapturing.Subject)
234                        .addToFields(new TemplateField(
235                                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'"))
236                        .addToFields(genotypeField)
237                        .addToFields(genotypeTypeField)
238                        .addToFields(genderField)
239                        .addToFields(new TemplateField(
240                                name: 'Age', type: TemplateFieldType.INTEGER, unit: 'weeks', comment: 'Age at start of study'))
241                        .addToFields(new TemplateField(
242                                name: 'Age type',type: TemplateFieldType.STRINGLIST,
243                                listEntries: [new TemplateFieldListItem(name:'postnatal'),new TemplateFieldListItem(name:'embryonal')]))
244                        .addToFields(new TemplateField(
245                                name: 'Cage',type: TemplateFieldType.STRING,comment:'Indicate the cage used for housing (type and/or size)'))
246                        .addToFields(new TemplateField(
247                                name: '#Mice in cage',type: TemplateFieldType.INTEGER,comment:'If known, indicate the number of mice per cage'))
248                        .addToFields(new TemplateField(
249                                name: 'Litter size',type: TemplateFieldType.INTEGER,comment:'If known, indicate the litter size of the litter from which the subject originates'))
250                        .addToFields(new TemplateField(
251                                name: 'Weight', type: TemplateFieldType.DOUBLE, unit: 'gram',comment:'If known indicate the weight of the subject in grams at the start of the study'))
252                        .with { if (!validate()) { errors.each { println it} } else save()}
253
254                        // Human template
255                        println ".adding human subject template..."
256                        def humanTemplate = new Template(
257                                name: 'Human', entity: dbnp.studycapturing.Subject)
258                        .addToFields(genderField)
259                        .addToFields(ageField)
260                        .addToFields(new TemplateField(
261                                name: 'DOB',type: TemplateFieldType.DATE,comment:'Date of birth'))
262                        .addToFields(new TemplateField(
263                                name: 'Height',type: TemplateFieldType.DOUBLE, unit: 'm'))
264                        .addToFields(new TemplateField(
265                                name: 'Weight',type: TemplateFieldType.DOUBLE, unit: 'kg'))
266                        .addToFields(new TemplateField(
267                                name: 'BMI',type: TemplateFieldType.DOUBLE, unit: 'kg/m2',comment:'Body-mass-index'))
268                        .addToFields(new TemplateField(
269                                name: 'Race',type: TemplateFieldType.STRING,comment:'If known and of interest the ethnic group can be indicated'))
270                        .addToFields(new TemplateField(
271                                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.'))
272                        .addToFields(new TemplateField(
273                                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.'))
274                        .addToFields(new TemplateField(
275                                name: 'Systolic blood pressure',type: TemplateFieldType.FLOAT, unit: 'mmHg',comment:'Indicate the levels at the start of the study in mmHG'))
276                        .addToFields(new TemplateField(
277                                name: 'Diastolic blood pressure',type: TemplateFieldType.FLOAT, unit: 'mmHg',comment:'Indicate the levels at the start of the study in mmHG'))
278                        .addToFields(new TemplateField(
279                                name: 'Heart rate',type: TemplateFieldType.FLOAT, unit: 'beats/min',comment:'Indicate the heart rate at the start of in study in beats per minute'))
280                        .addToFields(new TemplateField(
281                                name: 'Run-in-food',type: TemplateFieldType.TEXT,comment:'If defined, give a short description of the food used before the measurements'))
282                        .with { if (!validate()) { errors.each { println it} } else save()}
283
284                        println ".adding sample remarks field"
285                        def sampleRemarksField = new TemplateField(
286                                name: 'Remarks',
287                                type: TemplateFieldType.TEXT
288                        )
289                        .with { if (!validate()) { errors.each { println it} } else save()}
290
291                        println ".adding sample vial textfield"
292                        def sampleVialTextField = new TemplateField(
293                                name: 'Text on vial',
294                                type: TemplateFieldType.STRING
295                        )
296                        .with { if (!validate()) { errors.each { println it} } else save()}
297
298                        // Human tissue sample template
299                        println ".adding human sample template..."
300                        def humanSampleTemplate = new Template(
301                                name: 'Human tissue sample',
302                                entity: dbnp.studycapturing.Sample
303                        )
304                        .addToFields(sampleRemarksField)
305                        .addToFields(sampleVialTextField)
306            .addToFields(
307                                new TemplateField(
308                        name: 'Sample measured weight',
309                        unit: 'mg',
310                        type: TemplateFieldType.FLOAT
311                                )
312                        )
313                        .with { if (!validate()) { errors.each { println it} } else save()}
314
315            // Human blood sample template
316            println ".adding human sample template..."
317            def humanBloodSampleTemplate = new Template(
318                name: 'Human blood sample',
319                                entity: dbnp.studycapturing.Sample
320                        )
321            .addToFields(sampleRemarksField)
322            .addToFields(sampleVialTextField)
323            .addToFields(
324                                new TemplateField(
325                        name: 'Sample measured volume',
326                        unit: 'ml',
327                        type: TemplateFieldType.FLOAT
328                                )
329                        )
330            .with { if (!validate()) { errors.each { println it} } else save()}
331
332                /*
333            def GrowthTreatmentTemplate = new Template(
334                                name: 'Growth treatment',
335                                entity: dbnp.studycapturing.Event
336                        )
337                        .addToFields(sampleDescriptionField)
338                        .addToFields(new TemplateField(name: 'position X',type: TemplateFieldType.STRING))
339            .addToFields(new TemplateField(name: 'position Y',type: TemplateFieldType.STRING))
340            .addToFields(new TemplateField(name: 'Block',type: TemplateFieldType.STRING))
341            .addToFields(new TemplateField(name: 'Temparature Day',type: TemplateFieldType.STRING))
342            .addToFields(new TemplateField(name: 'Temparature Night',type: TemplateFieldType.STRING))
343            .addToFields(new TemplateField(name: 'Light Intensity',type: TemplateFieldType.STRING))
344            .addToFields(new TemplateField(name: 'Harvest Delay',type: TemplateFieldType.STRING))
345            .with { if (!validate()) { errors.each { println it} } else save()}
346                */
347
348                        //Plant template
349                        println ".adding geenhouse plant template..."
350                        def greenHouseTemplate = new Template(
351                                name: 'Plant-green house ',
352                                entity: dbnp.studycapturing.Subject
353                        )
354                        .addToFields(varietyField)
355                .addToFields(ecotypeField)
356                .addToFields(genotypeField)
357            /*
358                        .addToFields(genotypeTypeField)
359                        .addToFields(
360                                new TemplateField(
361                                        name: 'Growth location', type: TemplateFieldType.STRINGLIST,
362                                        listEntries: [
363                                                new TemplateFieldListItem(name:'Greenhouse'),
364                                                new TemplateFieldListItem(name: 'Field')
365                                        ]
366                                )
367                        )
368                        .addToFields(
369                                new TemplateField(
370                                        name: 'Room', type: TemplateFieldType.STRING,
371                                        comment: 'Chamber number in case of Greenhouse'
372                                )
373                        )
374            */
375                .addToFields(
376                                new TemplateField(
377                                        name: 'Chamber no.',
378                                        type: TemplateFieldType.STRING,
379                                        comment: 'Chamber number in the Greenhouse'
380                                )
381                        )
382                .addToFields(
383                                new TemplateField(
384                                        name: 'Growth type',
385                                        type: TemplateFieldType.STRINGLIST,
386                                        listEntries: [
387                                                new TemplateFieldListItem(name:'Standard'),
388                        new TemplateFieldListItem(name: 'Experimental'),
389                        new TemplateFieldListItem(name: 'Unknown')
390                                        ]
391                                )
392                        )
393                        .addToFields(new TemplateField(
394                                name: 'Growth protocol', type: TemplateFieldType.TEXT))
395                .addToFields(new TemplateField(
396                                name: 'Position X', type: TemplateFieldType.FLOAT))
397                        .addToFields(new TemplateField(
398                                name: 'Position Y', type: TemplateFieldType.FLOAT))
399                        .addToFields(new TemplateField(
400                                name: 'Block', type: TemplateFieldType.STRING))
401                        .addToFields(new TemplateField(
402                                name: 'Temperature at day', type: TemplateFieldType.FLOAT))
403                        .addToFields(new TemplateField(
404                                name: 'Temperature at night', type: TemplateFieldType.FLOAT))
405                        .addToFields(new TemplateField(
406                                name: 'Photo period', type: TemplateFieldType.STRING))
407                        .addToFields(new TemplateField(
408                                name: 'Light intensity', type: TemplateFieldType.STRING))
409                        .addToFields(new TemplateField(
410                                name: 'Start date', type: TemplateFieldType.DATE))
411                        .addToFields(new TemplateField(
412                                name: 'Harvest date', type: TemplateFieldType.DATE))
413                        .addToFields(new TemplateField(
414                                name: 'Harvest delay', type: TemplateFieldType.TEXT))
415                        .addToFields(new TemplateField(
416                                name: 'Additional info', type: TemplateFieldType.TEXT))
417                .with { if (!validate()) { errors.each { println it} } else save()}
418
419            println ".adding open-field plant template..."
420                        def FieldTemplate = new Template(
421                                name: 'Plant-open field',
422                                entity: dbnp.studycapturing.Subject
423                        )
424                        .addToFields(varietyField)
425                        .addToFields(ecotypeField)
426                        .addToFields(genotypeField)
427            .addToFields(new TemplateField(
428                                name: 'Start date', type: TemplateFieldType.DATE))
429                        .addToFields(new TemplateField(
430                                name: 'Harvest date', type: TemplateFieldType.DATE))
431                        .addToFields(new TemplateField(
432                                name: 'Growth type', type: TemplateFieldType.STRINGLIST,
433                                listEntries: [new TemplateFieldListItem(name:'Standard'),new TemplateFieldListItem(name: 'Experimental')]))
434                        .addToFields(new TemplateField(
435                                name: 'Growth protocol', type: TemplateFieldType.TEXT))
436                        .addToFields(new TemplateField(
437                                name: 'Harvest delay', type: TemplateFieldType.TEXT))
438                .with { if (!validate()) { errors.each { println it} } else save()}
439
440            //Plant template
441                        println ".adding chamber plant template..."
442                        def chamberTemplate = new Template(
443                                name: 'Plant-chamber',
444                                entity: dbnp.studycapturing.Subject
445                        )
446                        .addToFields(varietyField)
447            .addToFields(ecotypeField)
448            .addToFields(genotypeField)
449                        /*
450                        .addToFields(genotypeTypeField)
451                        .addToFields(
452                                new TemplateField(
453                                        name: 'Growth location',
454                                        type: TemplateFieldType.STRINGLIST,
455                                        listEntries: [
456                                                new TemplateFieldListItem(name:'Greenhouse'),
457                                                new TemplateFieldListItem(name: 'Field')
458                                        ]
459                                )
460                        )
461                        */
462                        .addToFields(new TemplateField(
463                                name: 'Room', type: TemplateFieldType.STRING,
464                                comment: 'room number'))
465                        .addToFields(new TemplateField(
466                                name: 'Chamber no.', type: TemplateFieldType.STRING,
467                                comment: 'Chamber number'))
468                        .addToFields(new TemplateField(
469                                name: 'Block', type: TemplateFieldType.STRING))
470                        .addToFields(new TemplateField(
471                                name: 'Position X', type: TemplateFieldType.FLOAT))
472                        .addToFields(new TemplateField(
473                                name: 'Position Y', type: TemplateFieldType.FLOAT))
474                        .addToFields(new TemplateField(
475                                name: 'Temperature at day', type: TemplateFieldType.FLOAT))
476                        .addToFields(new TemplateField(
477                                name: 'Temperature at night', type: TemplateFieldType.FLOAT))
478                        .addToFields(new TemplateField(
479                                name: 'Photo period', type: TemplateFieldType.STRING))
480                        .addToFields(new TemplateField(
481                                name: 'Light intensity', type: TemplateFieldType.STRING))
482                        .addToFields(new TemplateField(
483                                name: 'Start date', type: TemplateFieldType.DATE))
484                        .addToFields(new TemplateField(
485                                name: 'Harvest date', type: TemplateFieldType.DATE))
486                        .addToFields(new TemplateField(
487                                name: 'Growth type', type: TemplateFieldType.STRINGLIST,
488                                listEntries: [new TemplateFieldListItem(name:'Standard'),new TemplateFieldListItem(name: 'Experimental')]))
489                        .addToFields(new TemplateField(
490                                name: 'Growth protocol', type: TemplateFieldType.TEXT))
491                        .addToFields(new TemplateField(
492                                name: 'Harvest delay', type: TemplateFieldType.TEXT))
493                        .with { if (!validate()) { errors.each { println it} } else save()}
494
495                        println ".adding plant sample template..."
496                        def plantSampleTemplate = new Template(
497                                name: 'Plant sample',
498                                entity: dbnp.studycapturing.Sample
499                        )
500                        .addToFields(sampleRemarksField)
501                        .addToFields(sampleVialTextField)
502                        .with { if (!validate()) { errors.each { println it} } else save()}
503
504                        println ".adding material prep template"
505                        def materialPrepTemplate = new Template(
506                                name: 'Plant-material preparation',
507                description: 'material preparation',
508                entity: dbnp.studycapturing.Event
509                        )
510                        .addToFields(new TemplateField(
511                                name: 'Tissue',
512                                type: TemplateFieldType.STRING,
513                comment: 'organ/ fraction of culture/ plant part')
514                        )
515            .addToFields(
516                                new TemplateField(
517                                        name: 'Grinding',
518                                        type: TemplateFieldType.STRINGLIST,
519                        listEntries: [
520                                                new TemplateFieldListItem(name:'yes'),
521                            new TemplateFieldListItem(name: 'no'),
522                            new TemplateFieldListItem(name: 'unknown')
523                                        ]
524                                )
525                        )
526                        .addToFields(
527                                new TemplateField(
528                                        name: 'Storage location',
529                                        type: TemplateFieldType.STRING
530                                )
531                        )
532                        .addToFields(
533                                new TemplateField(
534                                        name: 'protocol reference',
535                                        type: TemplateFieldType.STRING
536                                )
537                        )
538                        .with { if (!validate()) { errors.each { println it} } else save()}
539
540                        // diet treatment template
541                        println ".adding diet treatement template"
542                        def dietTreatmentTemplate = new Template(
543                                name: 'Diet treatment HF45/LF10',
544                                entity: dbnp.studycapturing.Event
545                        )
546                        .addToFields(
547                                new TemplateField(
548                                        name: 'Diet',
549                                        type: TemplateFieldType.STRINGLIST,
550                                        listEntries: [
551                                                new TemplateFieldListItem(name:'10% fat (palm oil)'),
552                                                new TemplateFieldListItem(name: '45% fat (palm oil)')
553                                        ]
554                                )
555                        )
556                        .with { if (!validate()) { errors.each { println it} } else save()}
557
558                        // boost treatment template
559                        println ".adding boost treatment template"
560                        def boostTreatmentTemplate = new Template(
561                                name: 'Leptin treatment',
562                                entity: dbnp.studycapturing.Event
563                        )
564                        .addToFields(
565                                new TemplateField(
566                                        name: 'Compound',
567                                        type: TemplateFieldType.STRINGLIST,
568                                        listEntries: [
569                                                new TemplateFieldListItem(name:'Vehicle'),
570                                                new TemplateFieldListItem(name: 'Leptin')
571                                        ]
572                                )
573                        )
574                        .with { if (!validate()) { errors.each { println it} } else save()}
575
576                        // fasting treatment template
577                        println ".adding fasting treatment template"
578                        def fastingTreatment = new Template(
579                                name: 'Fasting treatment',
580                                description: 'Fasting Protocol NuGO PPSH',
581                                entity: dbnp.studycapturing.Event
582                        )
583            .addToFields(
584                                new TemplateField(
585                                        name: 'Fasting period',
586                                        type: TemplateFieldType.STRING
587                                )
588                        )
589                        .with { if (!validate()) { errors.each { println it} } else save()}
590
591                        // SamplingEvent templates
592                        println ".adding sampling protocol template field"
593            def samplingProtocolField = new TemplateField(
594                name: 'Sample Protocol',
595                                type: TemplateFieldType.STRING
596                        )
597            .with { if (!validate()) { errors.each { println it} } else save()}
598
599                        // liver sampling event template
600                        println ".adding liver sampling event template"
601                        def liverSamplingEventTemplate = new Template(
602                                name: 'Liver extraction',
603                                description: 'Liver sampling for transcriptomics arrays',
604                                entity: dbnp.studycapturing.SamplingEvent
605                        )
606                        .addToFields(samplingProtocolField)
607                        .addToFields(
608                                new TemplateField(
609                                        name: 'Sample weight',
610                                        unit: 'mg',
611                                        type: TemplateFieldType.FLOAT
612                                )
613                        )
614                        .with { if (!validate()) { errors.each { println it} } else save()}
615
616                        // blood sampling
617                        println ".adding blood sampling event template"
618                        def bloodSamplingEventTemplate = new Template(
619                                name: 'Blood extraction',
620                                description: 'Blood extraction targeted at lipid assays',
621                        entity: dbnp.studycapturing.SamplingEvent
622                        )
623            .addToFields(samplingProtocolField)
624                        .addToFields(
625                                new TemplateField(
626                                        name: 'Sample volume',
627                                        unit: 'ml',
628                                        type: TemplateFieldType.FLOAT
629                                )
630                        )
631                        .with { if (!validate()) { errors.each { println it} } else save()}
632
633                        // plant sample extraction event template
634                        println ".adding plant sample extraction event template"
635                        def plantSamplingExtractEventTemplate = new Template(
636                                name: 'Plant sample extraction',
637                                description: 'sample extraction',
638                                entity: dbnp.studycapturing.SamplingEvent,
639                sampleTemplates: [plantSampleTemplate]
640                        )
641            .addToFields(samplingProtocolField)
642                        .addToFields(
643                                new TemplateField(
644                                        name: 'Sample weight',
645                                        unit: 'ul',
646                                        type: TemplateFieldType.FLOAT
647                                )
648                        )
649                        .addToFields(
650                                new TemplateField(
651                                        name: 'Sample when measured',
652                                        type: TemplateFieldType.STRINGLIST,
653                        listEntries: [
654                                                 new TemplateFieldListItem(name:'Dried'),
655                         new TemplateFieldListItem(name: 'Fresh'),
656                         new TemplateFieldListItem(name: 'Unknown')
657                                         ]
658                                )
659                        )
660                        .with { if (!validate()) { errors.each { println it} } else save()}
661
662                        // plant sampling event template
663                        println ".adding plant sampling event template"
664            def plantSamplingEventTemplate = new Template(
665                                name: 'Plant-sample ',
666                                description: 'plant sample ',
667                                entity: dbnp.studycapturing.SamplingEvent,
668                sampleTemplates: [plantSampleTemplate]
669                        )
670            //.addToFields(samplingProtocolField)
671                        .addToFields(
672                                new TemplateField(
673                                        name: 'material',
674                        comment: 'physical charecteristic. e.g, grounded powder of tomato seed or liquid',
675                                        type: TemplateFieldType.STRING
676                                )
677                        )
678            .addToFields(
679                                new TemplateField(
680                                        name: 'Desription',
681                                        type: TemplateFieldType.STRING
682                                )
683                        )
684            .addToFields(
685                                new TemplateField(
686                                        name: 'extracted material',
687                                        comment: 'substance to be extracted. e.g., lipids, volatiles, primary metabolites etc',
688                                        type: TemplateFieldType.STRING
689                                )
690                        )
691            .addToFields(
692                                new TemplateField(
693                                        name: 'Text on vial',
694                                        type: TemplateFieldType.STRING
695                                )
696                        )
697                        .with { if (!validate()) { errors.each { println it} } else save()}
698
699                        // Add example studies
700                        if (!(grails.util.GrailsUtil.environment == GrailsApplication.ENV_TEST)) {
701                                println ".adding NuGO PPS3 leptin example study..."
702                                def mouseStudy = new Study(
703                                        template: studyTemplate,
704                                        title:"NuGO PPS3 mouse study leptin module",
705                                        code:"PPS3_leptin_module",
706                                        researchQuestion:"Leptin etc.",
707                                        ecCode:"2007117.c",
708                                        startDate: Date.parse('yyyy-MM-dd','2008-01-02'),
709                                        externalStudyID: 1
710                                )
711                                .with { if (!validate()) { errors.each { println it} } else save()}
712
713                                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." )
714                                mouseStudy.save()
715
716                                def evLF = new Event(
717                                        startTime: 3600,
718                                        endTime: 3600 +7 * 24 * 3600,
719                                        template: dietTreatmentTemplate
720                                )
721                                .setFieldValue( 'Diet','10% fat (palm oil)')
722                                .with { if (!validate()) { errors.each { println it} } else save()}
723
724                                def evHF = new Event(
725                                        startTime: 3600,
726                                        endTime: 3600 +7 * 24 * 3600,
727                                        template: dietTreatmentTemplate
728                                )
729                                .setFieldValue( 'Diet','45% fat (palm oil)' )
730                                .with { if (!validate()) { errors.each { println it} } else save()}
731
732                                def evBV = new Event(
733                                        startTime: 3600,
734                                        endTime: 3600 +7 * 24 * 3600,
735                                        template: boostTreatmentTemplate
736                                )
737                                .setFieldValue( 'Compound','Vehicle' )
738                                .with { if (!validate()) { errors.each { println it} } else save()}
739
740                                def evBL = new Event(
741                                        startTime: 3600,
742                                        endTime: 3600 +7 * 24 * 3600,
743                                        template: boostTreatmentTemplate
744                                )
745                                .setFieldValue( 'Compound','Leptin' )
746                                .with { if (!validate()) { errors.each { println it} } else save()}
747
748                                def evLF4 = new Event(
749                                        startTime: 3600,
750                                        endTime: 3600 + 4 * 7 * 24 * 3600,
751                                        template: dietTreatmentTemplate
752                                )
753                                .setFieldValue( 'Diet','10% fat (palm oil)')
754                                .with { if (!validate()) { errors.each { println it} } else save()}
755
756                                def evHF4 = new Event(
757                                        startTime: 3600,
758                                        endTime: 3600 + 4 * 7 * 24 * 3600,
759                                        template: dietTreatmentTemplate
760                                )
761                                .setFieldValue( 'Diet','45% fat (palm oil)' )
762                                .with { if (!validate()) { errors.each { println it} } else save()}
763
764                                def evBV4 = new Event(
765                                        startTime: 3600,
766                                        endTime: 3600 + 4 * 7 * 24 * 3600,
767                                        template: boostTreatmentTemplate
768                                )
769                                .setFieldValue( 'Compound','Vehicle' )
770                                .with { if (!validate()) { errors.each { println it} } else save()}
771
772                                def evBL4 = new Event(
773                                        startTime: 3600,
774                                        endTime: 3600 + 4 * 7 * 24 * 3600,
775                                        template: boostTreatmentTemplate
776                                )
777                                .setFieldValue( 'Compound','Leptin' )
778                                .with { if (!validate()) { errors.each { println it} } else save()}
779
780                                def evS = new SamplingEvent(
781                                        startTime: 3600 +7 * 24 * 3600,
782                                        endTime: 3600 +7 * 24 * 3600,
783                                        template: liverSamplingEventTemplate)
784                                .setFieldValue('Sample weight',5F)
785                                .with { if (!validate()) { errors.each { println it} } else save()}
786
787                                def evS4 = new SamplingEvent(
788                                        startTime: 3600 +7 * 24 * 3600,
789                                        endTime: 3600 +7 * 24 * 3600,
790                                        template: liverSamplingEventTemplate)
791                                .setFieldValue('Sample weight',5F)
792                                .with { if (!validate()) { errors.each { println it} } else save()}
793
794                                // Add events to study
795                                mouseStudy
796                                .addToEvents(evLF)
797                                .addToEvents(evHF)
798                                .addToEvents(evBV)
799                                .addToEvents(evBL)
800                                .addToEvents(evLF4)
801                                .addToEvents(evHF4)
802                                .addToEvents(evBV4)
803                                .addToEvents(evBL4)
804                                .addToSamplingEvents(evS)
805                                .addToSamplingEvents(evS4)
806                                .save()
807
808                                def LFBV1 = new EventGroup(name:"10% fat + vehicle for 1 week")
809                                .addToEvents(evLF)
810                                .addToEvents(evBV)
811                                .addToEvents(evS)
812                                .with { if (!validate()) { errors.each { println it} } else save()}
813
814                                def LFBL1 = new EventGroup(name:"10% fat + leptin for 1 week")
815                                .addToEvents(evLF)
816                                .addToEvents(evBL)
817                                .addToEvents(evS)
818                                .with { if (!validate()) { errors.each { println it} } else save()}
819
820                                def HFBV1 = new EventGroup(name:"45% fat + vehicle for 1 week")
821                                .addToEvents(evHF)
822                                .addToEvents(evBV)
823                                .addToEvents(evS)
824                                .with { if (!validate()) { errors.each { println it} } else save()}
825
826                                def HFBL1 = new EventGroup(name:"45% fat + leptin for 1 week")
827                                .addToEvents(evHF)
828                                .addToEvents(evBL)
829                                .addToEvents(evS)
830                                .with { if (!validate()) { errors.each { println it} } else save()}
831
832                                def LFBV4 = new EventGroup(name:"10% fat + vehicle for 4 weeks")
833                                .addToEvents(evLF4)
834                                .addToEvents(evBV4)
835                                .addToEvents(evS4)
836                                .with { if (!validate()) { errors.each { println it} } else save()}
837
838                                def LFBL4 = new EventGroup(name:"10% fat + leptin for 4 weeks")
839                                .addToEvents(evLF4)
840                                .addToEvents(evBL4)
841                                .addToEvents(evS4)
842                                .with { if (!validate()) { errors.each { println it} } else save()}
843
844                                def HFBV4 = new EventGroup(name:"45% fat + vehicle for 4 weeks")
845                                .addToEvents(evHF4)
846                                .addToEvents(evBV4)
847                                .addToEvents(evS4)
848                                .with { if (!validate()) { errors.each { println it} } else save()}
849
850                                def HFBL4 = new EventGroup(name:"45% fat + leptin for 4 weeks")
851                                .addToEvents(evHF4)
852                                .addToEvents(evBL4)
853                                .addToEvents(evS4)
854                                .with { if (!validate()) { errors.each { println it} } else save()}
855
856                // Add subjects and samples and compose EventGroups
857                                def x=1
858                                20.times {
859                                        def currentSubject = new Subject(
860                                                name: "A" + x++,
861                                                species: mouseTerm,
862                                                template: mouseTemplate,
863                                        )
864                                        .setFieldValue("Gender", "Male")
865                                        .setFieldValue("Genotype", c57bl6Term)
866                                        .setFieldValue("Age", 17)
867                                        .setFieldValue("Cage", "" + (int)(x/2))
868                                        .with { if (!validate()) { errors.each { println it} } else save(flush:true)}
869
870                                        mouseStudy.addToSubjects(currentSubject)
871                                        .with { if (!validate()) { errors.each { println it} } else save()}
872
873                                        // Add subject to appropriate EventGroup
874                                        if (x > 70) { HFBL4.addToSubjects(currentSubject).save() }
875                                        else if (x > 60) { HFBV4.addToSubjects(currentSubject).save() }
876                                        else if (x > 50) { LFBL4.addToSubjects(currentSubject).save() }
877                                        else if (x > 40) { LFBV4.addToSubjects(currentSubject).save() }
878                                        else if (x > 30) { HFBL1.addToSubjects(currentSubject).save() }
879                                        else if (x > 20) { HFBV1.addToSubjects(currentSubject).save() }
880                                        else if (x > 10) { LFBL1.addToSubjects(currentSubject).save() }
881                                        else             { LFBV1.addToSubjects(currentSubject).save() }
882
883                                }
884
885                                // Add EventGroups to study
886                                mouseStudy
887                                .addToEventGroups(LFBV1)
888                                .addToEventGroups(LFBL1)
889                                .addToEventGroups(HFBV1)
890                                .addToEventGroups(HFBL1)
891                                .addToEventGroups(LFBV4)
892                                .addToEventGroups(LFBL4)
893                                .addToEventGroups(HFBV4)
894                                .addToEventGroups(HFBL4)
895
896                                // Add persons and publications to study
897                                def studyperson1 = new StudyPerson( person: person1, role: role1 ).save();
898                                def studyperson2 = new StudyPerson( person: person2, role: role2 ).save();
899
900                                mouseStudy
901                                .addToPersons( studyperson1 )
902                                .addToPersons( studyperson2 )
903                .addToPublications( publication1 )
904                .addToPublications( publication2 )
905                                .save()
906
907                                println ".adding NuGO PPSH example study..."
908
909                                def humanStudy = new Study(
910                                        template: studyTemplate,
911                                        title:"NuGO PPS human study",
912                                        code:"PPSH",
913                                        researchQuestion:"How much are fasting plasma and urine metabolite levels affected by prolonged fasting ?",
914                                        description:"Human study",
915                                        ecCode:"unknown",
916                                        startDate: Date.parse('yyyy-MM-dd','2008-01-14'),
917                                        externalStudyID: 2
918                                )
919                                .setFieldValue( 'Description', "Human study performed at RRI; centres involved: RRI, IFR, TUM, Maastricht U." )
920                                .with { if (!validate()) { errors.each { println it} } else save()}
921
922                                def rootGroup = new EventGroup(name: 'Root group');
923
924                                def fastingEvent = new Event(
925                                        startTime: 3 * 24 * 3600 + 22 * 3600,
926                                        endTime: 3 * 24 * 3600 + 30 * 3600,
927                                        template: fastingTreatment)
928                                .setFieldValue('Fasting period','8h');
929
930
931                                def bloodSamplingEvent = new SamplingEvent(
932                                        startTime: 3 * 24 * 3600 + 30 * 3600,
933                                        endTime: 3 * 24 * 3600 + 30 * 3600,
934                                        template: bloodSamplingEventTemplate)
935                                .setFieldValue('Sample volume',4.5F);
936
937                                rootGroup.addToEvents fastingEvent
938                                rootGroup.addToEvents bloodSamplingEvent
939                                rootGroup.save()
940
941                                def y = 1
942                                11.times {
943                                        def currentSubject = new Subject(
944                                                name: "" + y++,
945                                                species: humanTerm,
946                                                template: humanTemplate
947                                        )
948                                        .setFieldValue("Gender", (Math.random() > 0.5) ? "Male" : "Female")
949                                        .setFieldValue("DOB", new java.text.SimpleDateFormat("dd-mm-yy").parse("01-02-19" + (10 + (int) (Math.random() * 80))))
950                                        .setFieldValue("Age", 30)
951                                        .setFieldValue("Height", Math.random() * 2F)
952                                        .setFieldValue("Weight", Math.random() * 150F)
953                                        .setFieldValue("BMI", 20 + Math.random() * 10F)
954                                        .with { if (!validate()) { errors.each { println it} } else save()}
955
956                                        rootGroup.addToSubjects currentSubject
957                                        rootGroup.save()
958
959                                        def currentSample = new Sample(
960                                                name: currentSubject.name + '_B',
961                                                material: bloodTerm,
962                                                template: humanBloodSampleTemplate,
963                                                parentSubject: currentSubject,
964                                                parentEvent: bloodSamplingEvent
965                                        );
966                                        currentSample.setFieldValue( "Text on vial", "T" + (Math.random() * 100L) )
967
968                                        humanStudy.addToSubjects(currentSubject).addToSamples(currentSample).with { if (!validate()) { errors.each { println it} } else save()}
969                                }
970
971                                humanStudy.addToEvents(fastingEvent)
972                                humanStudy.addToSamplingEvents(bloodSamplingEvent)
973                                humanStudy.addToEventGroups rootGroup
974
975
976                                // Add persons to study
977                                def studyperson3 = new StudyPerson( person: person1, role: role2 ).save();
978
979                                humanStudy
980                                .addToPersons( studyperson3 )
981                                .addToPublications( publication2 )
982                                .save()
983
984                                /*
985                                // Add clinical data
986
987                                def lipidAssay = new dbnp.clinicaldata.ClinicalAssay(
988                                        name: 'Lipid profile',
989                                        approved: true
990                                ).with { if (!validate()) { errors.each { println it} } else save()}
991
992                                def ldlMeasurement = new dbnp.clinicaldata.ClinicalMeasurement(
993                                        name: 'LDL',
994                                        unit: 'mg/dL',
995                                        type: dbnp.data.FeatureType.QUANTITATIVE,
996                                        referenceValues: '100 mg/dL',
997                                        detectableLimit: 250,
998                                        isDrug: false, isIntake: true, inSerum: true
999                                ).with { if (!validate()) { errors.each { println it} } else save()}
1000
1001                                def hdlMeasurement = new dbnp.clinicaldata.ClinicalMeasurement(
1002                                        name: 'HDL',
1003                                        unit: 'mg/dL',
1004                                        type: dbnp.data.FeatureType.QUANTITATIVE,
1005                                        referenceValues: '50 mg/dL',
1006                                        detectableLimit: 100,
1007                                        isDrug: false, isIntake: true, inSerum: true
1008                                ).with { if (!validate()) { errors.each { println it} } else save()}
1009
1010                                lipidAssay.addToMeasurements ldlMeasurement
1011                                lipidAssay.addToMeasurements hdlMeasurement
1012
1013                                def lipidAssayInstance = new dbnp.clinicaldata.ClinicalAssayInstance(
1014                                        assay: lipidAssay
1015                                ).with { if (!validate()) { errors.each { println it} } else save()}
1016
1017                                humanStudy.samples*.each {
1018                                        new dbnp.clinicaldata.ClinicalFloatData(
1019                                                assay: lipidAssayInstance,
1020                                                measurement: ldlMeasurement,
1021                                                sample: it.name,
1022                                                value: Math.round(Math.random()*ldlMeasurement.detectableLimit)
1023                                        ).with { if (!validate()) { errors.each { println it} } else save()}
1024
1025                                        new dbnp.clinicaldata.ClinicalFloatData(
1026                                                assay: lipidAssayInstance,
1027                                                measurement: hdlMeasurement,
1028                                                sample: it.name,
1029                                                value: Math.round(Math.random()*hdlMeasurement.detectableLimit)
1030                                        ).with { if (!validate()) { errors.each { println it} } else save()}
1031                                }
1032                                */
1033                                // Add assay to study capture module
1034
1035                                def clinicalModule = new AssayModule(
1036                                        name: 'Clinical data',
1037                                        type: AssayType.CLINICAL_DATA,
1038                                        platform: 'clinical measurements',
1039                                        url: 'http://localhost:8080/gscf'
1040                                ).with { if (!validate()) { errors.each { println it} } else save()}
1041
1042                                def lipidAssayRef = new Assay(
1043                                        name: 'Lipid profiling',
1044                                        module: clinicalModule,
1045                                        externalAssayId: 0
1046                                ).with { if (!validate()) { errors.each { println it} } else save()}
1047
1048                                humanStudy.samples*.each {
1049                                        lipidAssayRef.addToSamples(it)
1050                                }
1051                                lipidAssayRef.save()
1052
1053                                humanStudy.addToAssays(lipidAssayRef);
1054                                humanStudy.save()
1055
1056                        mouseStudy.addToAssays(lipidAssayRef);
1057                                mouseStudy.save()
1058
1059                        }
1060                }
1061
1062                // Ontologies must be connected to the templatefields in runtime
1063                // because the Ontology.findByNcboId is not available otherwise
1064                TemplateEntity.getField(Subject.domainFields, 'species').ontologies = [Ontology.findByNcboId(1132)]
1065                TemplateEntity.getField(Sample.domainFields, 'material').ontologies = [Ontology.findByNcboId(1005)]
1066
1067        }
1068
1069        def destroy = {
1070        }
1071} 
Note: See TracBrowser for help on using the repository browser.