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

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