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

Last change on this file since 561 was 561, checked in by keesvb, 9 years ago

version 0.3.0: fixed some issues with updating boolean fields, changed events in the bootstrap, restructured menus

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