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

Last change on this file since 550 was 550, checked in by keesvb, 11 years ago

added entity property to TemplateField?; added validator to Template to ensure fields are of the correct entity, updated BootStrap? accordingly, updated tests accordingly

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