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

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