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

Last change on this file since 562 was 562, checked in by keesvb, 8 years ago

version 0.3.1: re-enabled saving and deleted >0 subjects requirement in create wizard, disabled test persons/publications in BootStrap?

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