source: trunk/grails-app/conf/BootStrapTemplates.groovy @ 936

Last change on this file since 936 was 870, checked in by duh, 12 years ago
  • forced flushing to the database in Template boostrapping for templates which are used during the initial bootstrapping process as otherwise the bootstrap will break on PostgreSQL. We have tried this previously everywhere in the bootstrap but removed it because it was too slow. Enabled it it only for the troubling templates to make sure the bootstrap will run as expected in production environments...
  • Property svn:keywords set to Author Date Rev
File size: 26.1 KB
Line 
1/**
2 * @Author kees
3 * @Since Jun 25, 2010
4 *
5 * Revision information:
6 * $Rev: 870 $
7 * $Author: t.w.abma@umcutrecht.nl $
8 * $Date: 2010-09-02 11:06:54 +0000 (do, 02 sep 2010) $
9 */
10
11import dbnp.studycapturing.*
12import dbnp.data.Ontology
13
14class BootStrapTemplates {
15
16        /**
17         * Add the ontologies that are necessary for the templates below manually
18         * This function can be called to avoid the HTTP requests to BioPortal each time
19         * (e.g. in development or automated test environments)
20         */
21        public static void initTemplateOntologies() {
22
23                // add Subject>species ontology
24                println ".adding NCBI species ontology"
25                def speciesOntology = new Ontology(
26                        name: 'NCBI organismal classification',
27                        description: 'A taxonomic classification of living organisms and associated artifacts for their controlled description within the context of databases.',
28                        url: 'http://www.ncbi.nlm.nih.gov/Taxonomy/taxonomyhome.html/',
29                        versionNumber: '1.2',
30                        ncboId: '1132',
31                        ncboVersionedId: '38802'
32                ).with { if (!validate()) { errors.each { println it} } else save()}
33
34                // add Sample>material ontology
35                println ".adding BRENDA source material ontology"
36                def brendaOntology = new Ontology(
37                        name: 'BRENDA tissue / enzyme source',
38                        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.',
39                        url: 'http://www.brenda-enzymes.info',
40                        versionNumber: '1.3',
41                        ncboId: '1005',
42                        ncboVersionedId: '40643'
43                ).with { if (!validate()) { errors.each { println it} } else save()}
44
45                // add NCI ontology which is used in Mouse genotype template field
46                def nciOntology = new Ontology(
47                        name: 'NCI Thesaurus',
48                        description: 'A vocabulary for clinical care, translational and basic research, and public information and administrative activities.',
49                        url: 'http://ncicb.nci.nih.gov/core/EVS',
50                        versionNumber: '10.01',
51                        ncboId: '1032',
52                        ncboVersionedId: '42693'
53                ).with { if (!validate()) { errors.each { println it} } else save()}
54
55                // add CHEBI ontology which is used in Mouse genotype template field
56                def chebiOntology = new Ontology(
57                        name: 'Chemical entities of biological interest',
58                        description: 'A structured classification of chemical compounds of biological relevance.',
59                        url: 'http://www.ebi.ac.uk/chebi',
60                        versionNumber: '1.68',
61                        ncboId: '1007',
62                        ncboVersionedId: '42878'
63                ).with { if (!validate()) { errors.each { println it} } else save()}
64               
65        }
66
67        /**
68         * Add example templates, this function would normally be called on an empty database
69         */
70        public static void initTemplates() {
71
72                // Create templates
73                println ".adding example templates"
74
75                def genderField = new TemplateField(
76                        name: 'Gender',type: TemplateFieldType.STRINGLIST, entity: Subject,
77                        listEntries: [new TemplateFieldListItem(name:'Male'),new TemplateFieldListItem(name: 'Female'),new TemplateFieldListItem(name: 'Unknown')])
78                .with { if (!validate()) { errors.each { println it} } else save()}
79
80                def ageField = new TemplateField(
81                        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)')
82                .with { if (!validate()) { errors.each { println it} } else save()}
83
84                def genotypeField = new TemplateField(
85                        name: 'Genotype', type: TemplateFieldType.STRING,entity: Subject,
86                        comment: 'If present, indicate the genetic variance of the subject (e.g., mutagenized populations,knock-out/in,transgene etc)')
87                .with { if (!validate()) { errors.each { println it} } else save()}
88
89                 def genotypeTypeField = new TemplateField(
90                        name: 'Genotype type',type: TemplateFieldType.STRINGLIST,entity: Subject,
91                        listEntries: [new TemplateFieldListItem(name:'wildtype'),
92                                new TemplateFieldListItem(name:'transgenic'),
93                                new TemplateFieldListItem(name:'knock-out'),
94                                new TemplateFieldListItem(name:'knock-in')],
95                        comment: 'If a genotype was specified, please indicate here the type of the genotype')
96                .with { if (!validate()) { errors.each { println it} } else save()}
97
98                def varietyField = new TemplateField(
99                        name: 'Variety', type: TemplateFieldType.STRING,entity: Subject,
100                        comment: 'taxonomic category consisting of members of a species that differ from others of the same species in minor but heritable characteristics')
101                .with { if (!validate()) { errors.each { println it} } else save()}
102
103                def ecotypeField = new TemplateField(
104                        name: 'Ecotype', type: TemplateFieldType.STRING,entity: Subject,
105                         comment: 'a type or subspecies of life that is especially well adapted to a certain environment'
106                )
107                 .with { if (!validate()) { errors.each { println it} } else save()}
108
109
110                // Nutritional study template
111                println ".adding academic study template..."
112                def studyTemplate = new Template(
113                        name: 'Academic study',
114                        entity: dbnp.studycapturing.Study
115                )
116                .addToFields(new TemplateField(name: 'Description',type: TemplateFieldType.TEXT, entity: Study,comment:'Describe here the type of subjects and the treatment, challenges and sampling.'))
117                .addToFields(new TemplateField(name: 'Objectives',type: TemplateFieldType.TEXT,entity: Study,comment:'Fill out the aim or questions of the study'))
118                .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'))
119                .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)'))
120                .addToFields(new TemplateField(name: 'Lab id',type: TemplateFieldType.STRING,entity: Study,comment:'In which lab was the study performed; indicate the roomnumber.'))
121                .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?)'))
122                .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'))
123                .with { if (!validate()) { errors.each { println it} } else save()}
124
125                // Mouse template
126                println ".adding mouse subject template..."
127                def mouseTemplate = new Template(
128                        name: 'Mouse', entity: dbnp.studycapturing.Subject)
129                .addToFields(new TemplateField(
130                        name: 'Strain', type: TemplateFieldType.ONTOLOGYTERM, ontologies: [Ontology.getOrCreateOntologyByNcboId(1032)], entity: Subject, comment: "This is an ontology term, if the right strain is not in the list please add it with 'add more'"))
131                .addToFields(genotypeField)
132                .addToFields(genotypeTypeField)
133                .addToFields(genderField)
134                .addToFields(new TemplateField(
135                        name: 'Age', type: TemplateFieldType.INTEGER, entity: Subject, unit: 'weeks', comment: 'Age at start of study'))
136                .addToFields(new TemplateField(
137                        name: 'Age type',type: TemplateFieldType.STRINGLIST,entity: Subject,
138                        listEntries: [new TemplateFieldListItem(name:'postnatal'),new TemplateFieldListItem(name:'embryonal')]))
139                .addToFields(new TemplateField(
140                        name: 'Cage',type: TemplateFieldType.STRING,entity: Subject,comment:'Indicate the cage used for housing (type and/or size)'))
141                .addToFields(new TemplateField(
142                        name: '#Mice in cage',type: TemplateFieldType.INTEGER,entity: Subject,comment:'If known, indicate the number of mice per cage'))
143                .addToFields(new TemplateField(
144                        name: 'Litter size',type: TemplateFieldType.INTEGER,entity: Subject,comment:'If known, indicate the litter size of the litter from which the subject originates'))
145                .addToFields(new TemplateField(
146                        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'))
147                .with { if (!validate()) { errors.each { println it} } else save()}
148
149                // Human template
150                println ".adding human subject template..."
151                def humanTemplate = new Template(
152                        name: 'Human', entity: dbnp.studycapturing.Subject)
153                .addToFields(genderField)
154                .addToFields(ageField)
155                .addToFields(new TemplateField(
156                        name: 'DOB',type: TemplateFieldType.DATE,entity: Subject,comment:'Date of birth'))
157                .addToFields(new TemplateField(
158                        name: 'Height',type: TemplateFieldType.DOUBLE, entity: Subject, unit: 'm'))
159                .addToFields(new TemplateField(
160                        name: 'Weight',type: TemplateFieldType.DOUBLE, entity: Subject, unit: 'kg'))
161                .addToFields(new TemplateField(
162                        name: 'BMI',type: TemplateFieldType.DOUBLE, entity: Subject, unit: 'kg/m2',comment:'Body-mass-index'))
163                .addToFields(new TemplateField(
164                        name: 'Race',type: TemplateFieldType.STRING,entity: Subject, comment:'If known and of interest the ethnic group can be indicated'))
165                .addToFields(new TemplateField(
166                        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.'))
167                .addToFields(new TemplateField(
168                        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.'))
169                .addToFields(new TemplateField(
170                        name: 'Systolic blood pressure',type: TemplateFieldType.FLOAT, unit: 'mmHg',entity: Subject, comment:'Indicate the levels at the start of the study in mmHG'))
171                .addToFields(new TemplateField(
172                        name: 'Diastolic blood pressure',type: TemplateFieldType.FLOAT, unit: 'mmHg',entity: Subject, comment:'Indicate the levels at the start of the study in mmHG'))
173                .addToFields(new TemplateField(
174                        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'))
175                .addToFields(new TemplateField(
176                        name: 'Run-in-food',type: TemplateFieldType.TEXT,entity: Subject, comment:'If defined, give a short description of the food used before the measurements'))
177                .with { if (!validate()) { errors.each { println it} } else save()}
178
179                println ".adding sample remarks field"
180                def sampleRemarksField = new TemplateField(
181                        name: 'Remarks',
182                        type: TemplateFieldType.TEXT,
183                    entity: Sample
184                )
185                .with { if (!validate()) { errors.each { println it} } else save()}
186
187                println ".adding sample vial textfield"
188                def sampleVialTextField = new TemplateField(
189                        name: 'Text on vial',
190                        type: TemplateFieldType.STRING,
191                    entity: Sample
192                )
193                .with { if (!validate()) { errors.each { println it} } else save()}
194
195                // Human tissue sample template
196                println ".adding human sample template..."
197                def humanSampleTemplate = new Template(
198                        name: 'Human tissue sample',
199                        entity: dbnp.studycapturing.Sample
200                )
201                .addToFields(sampleRemarksField)
202                .addToFields(sampleVialTextField)
203                .addToFields(
204                        new TemplateField(
205                            name: 'Sample measured weight',
206                            unit: 'mg',
207                            type: TemplateFieldType.FLOAT,
208                        entity: Sample
209                        )
210                )
211                .with { if (!validate()) { errors.each { println it} } else save()}
212
213                // Human blood sample template
214                println ".adding human sample template..."
215                def humanBloodSampleTemplate = new Template(
216                    name: 'Human blood sample',
217                        entity: dbnp.studycapturing.Sample
218                )
219                .addToFields(sampleRemarksField)
220                .addToFields(sampleVialTextField)
221                .addToFields(
222                        new TemplateField(
223                            name: 'Sample measured volume',
224                            unit: 'ml',
225                            type: TemplateFieldType.FLOAT,
226                                entity: Sample
227                        )
228                )
229                .with { if (!validate()) { errors.each { println it} } else save()}
230
231                /*
232                def GrowthTreatmentTemplate = new Template(
233                        name: 'Growth treatment',
234                        entity: dbnp.studycapturing.Event
235                )
236                .addToFields(sampleDescriptionField)
237                .addToFields(new TemplateField(name: 'position X',type: TemplateFieldType.STRING))
238                .addToFields(new TemplateField(name: 'position Y',type: TemplateFieldType.STRING))
239                .addToFields(new TemplateField(name: 'Block',type: TemplateFieldType.STRING))
240                .addToFields(new TemplateField(name: 'Temparature Day',type: TemplateFieldType.STRING))
241                .addToFields(new TemplateField(name: 'Temparature Night',type: TemplateFieldType.STRING))
242                .addToFields(new TemplateField(name: 'Light Intensity',type: TemplateFieldType.STRING))
243                .addToFields(new TemplateField(name: 'Harvest Delay',type: TemplateFieldType.STRING))
244                .with { if (!validate()) { errors.each { println it} } else save()}
245                 */
246
247                //Plant template
248                println ".adding geenhouse plant template..."
249                def greenHouseTemplate = new Template(
250                        name: 'Plant-green house ',
251                        entity: dbnp.studycapturing.Subject
252                )
253                .addToFields(varietyField)
254                .addToFields(ecotypeField)
255                 .addToFields(genotypeField)
256                /*
257                .addToFields(genotypeTypeField)
258                .addToFields(
259                        new TemplateField(
260                                name: 'Growth location', type: TemplateFieldType.STRINGLIST,
261                                listEntries: [
262                                        new TemplateFieldListItem(name:'Greenhouse'),
263                                        new TemplateFieldListItem(name: 'Field')
264                                ]
265                        )
266                )
267                .addToFields(
268                        new TemplateField(
269                                name: 'Room', type: TemplateFieldType.STRING,
270                                comment: 'Chamber number in case of Greenhouse'
271                        )
272                )
273                */
274                .addToFields(
275                        new TemplateField(
276                                name: 'Chamber no.',
277                                type: TemplateFieldType.STRING,
278                                entity: Subject,
279                                comment: 'Chamber number in the Greenhouse'
280                        )
281                )
282                .addToFields(
283                        new TemplateField(
284                                name: 'Growth type',
285                                entity: Subject,
286                                type: TemplateFieldType.STRINGLIST,
287                                listEntries: [
288                                        new TemplateFieldListItem(name:'Standard'),
289                                new TemplateFieldListItem(name: 'Experimental'),
290                                new TemplateFieldListItem(name: 'Unknown')
291                                ]
292                        )
293                )
294                .addToFields(new TemplateField(
295                        name: 'Growth protocol', entity: Subject, type: TemplateFieldType.TEXT))
296                .addToFields(new TemplateField(
297                        name: 'Position X', entity: Subject, type: TemplateFieldType.FLOAT))
298                .addToFields(new TemplateField(
299                        name: 'Position Y', entity: Subject, type: TemplateFieldType.FLOAT))
300                .addToFields(new TemplateField(
301                        name: 'Block', entity: Subject, type: TemplateFieldType.STRING))
302                .addToFields(new TemplateField(
303                        name: 'Temperature at day', entity: Subject, type: TemplateFieldType.FLOAT))
304                .addToFields(new TemplateField(
305                        name: 'Temperature at night', entity: Subject, type: TemplateFieldType.FLOAT))
306                .addToFields(new TemplateField(
307                        name: 'Photo period', entity: Subject, type: TemplateFieldType.STRING))
308                .addToFields(new TemplateField(
309                        name: 'Light intensity', entity: Subject, type: TemplateFieldType.STRING))
310                .addToFields(new TemplateField(
311                        name: 'Start date', entity: Subject, type: TemplateFieldType.DATE))
312                .addToFields(new TemplateField(
313                        name: 'Harvest date', entity: Subject, type: TemplateFieldType.DATE))
314                .addToFields(new TemplateField(
315                        name: 'Harvest delay', entity: Subject, type: TemplateFieldType.TEXT))
316                .addToFields(new TemplateField(
317                        name: 'Additional info', entity: Subject, type: TemplateFieldType.TEXT))
318                .with { if (!validate()) { errors.each { println it} } else save()}
319
320                println ".adding open-field plant template..."
321                def FieldTemplate = new Template(
322                        name: 'Plant-open field',
323                        entity: dbnp.studycapturing.Subject
324                )
325                .addToFields(varietyField)
326                .addToFields(ecotypeField)
327                .addToFields(genotypeField)
328                .addToFields(new TemplateField(
329                        name: 'Start date', entity: Subject, type: TemplateFieldType.DATE))
330                .addToFields(new TemplateField(
331                        name: 'Harvest date', entity: Subject, type: TemplateFieldType.DATE))
332                .addToFields(new TemplateField(
333                        name: 'Growth type', entity: Subject, type: TemplateFieldType.STRINGLIST,
334                        listEntries: [new TemplateFieldListItem(name:'Standard'),new TemplateFieldListItem(name: 'Experimental')]))
335                .addToFields(new TemplateField(
336                        name: 'Growth protocol', entity: Subject, type: TemplateFieldType.TEXT))
337                .addToFields(new TemplateField(
338                        name: 'Harvest delay', entity: Subject, type: TemplateFieldType.TEXT))
339                .with { if (!validate()) { errors.each { println it} } else save()}
340
341                //Plant template
342                println ".adding chamber plant template..."
343                def chamberTemplate = new Template(
344                        name: 'Plant-chamber',
345                        entity: dbnp.studycapturing.Subject
346                )
347                .addToFields(varietyField)
348                .addToFields(ecotypeField)
349                .addToFields(genotypeField)
350                /*
351                .addToFields(genotypeTypeField)
352                .addToFields(
353                        new TemplateField(
354                                name: 'Growth location',
355                                type: TemplateFieldType.STRINGLIST,
356                                listEntries: [
357                                        new TemplateFieldListItem(name:'Greenhouse'),
358                                        new TemplateFieldListItem(name: 'Field')
359                                ]
360                        )
361                )
362                */
363                .addToFields(new TemplateField(
364                        name: 'Room', type: TemplateFieldType.STRING, entity: Subject,
365                        comment: 'room number'))
366                .addToFields(new TemplateField(
367                        name: 'Chamber no.', type: TemplateFieldType.STRING, entity: Subject,
368                        comment: 'Chamber number'))
369                .addToFields(new TemplateField(
370                        name: 'Block', type: TemplateFieldType.STRING, entity: Subject))
371                .addToFields(new TemplateField(
372                        name: 'Position X', type: TemplateFieldType.FLOAT, entity: Subject))
373                .addToFields(new TemplateField(
374                        name: 'Position Y', type: TemplateFieldType.FLOAT, entity: Subject))
375                .addToFields(new TemplateField(
376                        name: 'Temperature at day', type: TemplateFieldType.FLOAT, entity: Subject))
377                .addToFields(new TemplateField(
378                        name: 'Temperature at night', type: TemplateFieldType.FLOAT, entity: Subject))
379                .addToFields(new TemplateField(
380                        name: 'Photo period', type: TemplateFieldType.STRING, entity: Subject))
381                .addToFields(new TemplateField(
382                        name: 'Light intensity', type: TemplateFieldType.STRING, entity: Subject))
383                .addToFields(new TemplateField(
384                        name: 'Start date', type: TemplateFieldType.DATE, entity: Subject))
385                .addToFields(new TemplateField(
386                        name: 'Harvest date', type: TemplateFieldType.DATE, entity: Subject))
387                .addToFields(new TemplateField(
388                        name: 'Growth type', type: TemplateFieldType.STRINGLIST, entity: Subject,
389                        listEntries: [new TemplateFieldListItem(name:'Standard'),new TemplateFieldListItem(name: 'Experimental')]))
390                .addToFields(new TemplateField(
391                        name: 'Growth protocol', type: TemplateFieldType.TEXT, entity: Subject))
392                .addToFields(new TemplateField(
393                        name: 'Harvest delay', type: TemplateFieldType.TEXT, entity: Subject))
394                .with { if (!validate()) { errors.each { println it} } else save()}
395
396                println ".adding plant sample template..."
397                def plantSampleTemplate = new Template(
398                        name: 'Plant sample',
399                        entity: dbnp.studycapturing.Sample
400                )
401                .addToFields(sampleRemarksField)
402                .addToFields(sampleVialTextField)
403                .with { if (!validate()) { errors.each { println it} } else save()}
404
405                println ".adding material prep template"
406                def materialPrepTemplate = new Template(
407                        name: 'Plant-material preparation',
408                    description: 'material preparation',
409                    entity: dbnp.studycapturing.Event
410                )
411                .addToFields(new TemplateField(
412                         name: 'Tissue',
413                        type: TemplateFieldType.STRING,
414                        entity: Event,
415                    comment: 'organ/ fraction of culture/ plant part')
416                )
417                .addToFields(
418                        new TemplateField(
419                                 name: 'Grinding',
420                                type: TemplateFieldType.STRINGLIST,
421                                entity: Event,
422                            listEntries: [
423                                        new TemplateFieldListItem(name:'yes'),
424                                new TemplateFieldListItem(name: 'no'),
425                                new TemplateFieldListItem(name: 'unknown')
426                                ]
427                        )
428                )
429                .addToFields(
430                        new TemplateField(
431                                name: 'Storage location',
432                                type: TemplateFieldType.STRING,
433                                entity: Event
434                        )
435                )
436                .addToFields(
437                        new TemplateField(
438                                name: 'protocol reference',
439                                type: TemplateFieldType.STRING,
440                                entity: Event
441                        )
442                )
443                .with { if (!validate()) { errors.each { println it} } else save()}
444
445                def protocolField = new TemplateField(
446                        name: 'Protocol',
447                        type: TemplateFieldType.FILE,
448                        entity: Event,
449                        comment: 'You can upload a protocol here which describes the procedure which was used when carrying out the event'
450                )
451                .with { if (!validate()) { errors.each { println it} } else save()}
452
453                // diet treatment template
454                println ".adding diet treatement template"
455                def dietTreatmentTemplate = new Template(
456                        name: 'Diet treatment',
457                        entity: dbnp.studycapturing.Event
458                )
459                .addToFields(
460                        new TemplateField(
461                                name: 'Diet',
462                                type: TemplateFieldType.STRINGLIST,
463                                entity: Event,
464                                listEntries: [
465                                        new TemplateFieldListItem(name:'low fat'),
466                                        new TemplateFieldListItem(name: 'high fat')
467                                ]
468                        )
469                )
470                .addToFields(protocolField)
471                .with { if (!validate()) { errors.each { println it} } else save(flush:true)}
472                dietTreatmentTemplate.refresh()
473
474                // boost treatment template
475                println ".adding boost treatment template"
476                def boostTreatmentTemplate = new Template(
477                        name: 'Compound challenge',
478                        entity: dbnp.studycapturing.Event
479                )
480                .addToFields(
481                        new TemplateField(
482                                name: 'Compound',
483                                type: TemplateFieldType.ONTOLOGYTERM,
484                                entity: Event,
485                                ontologies: [Ontology.getOrCreateOntologyByNcboId(1007)]
486                        )
487                )
488                .addToFields(
489                        new TemplateField(
490                                name: 'Control',
491                                type: TemplateFieldType.BOOLEAN,
492                                entity: Event
493                        )
494                )
495                .addToFields(protocolField)
496                .with { if (!validate()) { errors.each { println it} } else save(flush:true)}
497                boostTreatmentTemplate.refresh()
498
499                // fasting treatment template
500                println ".adding fasting treatment template"
501                def fastingTreatment = new Template(
502                        name: 'Fasting treatment',
503                        description: 'Fasting for a specific amount of time',
504                        entity: dbnp.studycapturing.Event
505                )
506                .addToFields(
507                        new TemplateField(
508                                name: 'Fasting period',
509                                type: TemplateFieldType.RELTIME,
510                                entity: Event
511                        )
512                )
513                .with { if (!validate()) { errors.each { println it} } else save()}
514
515                // SamplingEvent templates
516                println ".adding sampling protocol template field"
517                def samplingProtocolField = new TemplateField(
518                        name: 'Sample Protocol',
519                        entity: SamplingEvent,
520                        type: TemplateFieldType.FILE,
521                        comment: 'You can upload a protocol here which describes the procedure which was used when carrying out the sampling event'
522                )
523                .with { if (!validate()) { errors.each { println it} } else save()}
524
525                // liver sampling event template
526                println ".adding liver sampling event template"
527                def liverSamplingEventTemplate = new Template(
528                        name: 'Liver extraction',
529                        description: 'Liver sampling for transcriptomics arrays',
530                        entity: dbnp.studycapturing.SamplingEvent
531                )
532                .addToFields(samplingProtocolField)
533                .addToFields(
534                        new TemplateField(
535                                name: 'Sample weight',
536                                unit: 'mg',
537                                entity: SamplingEvent,
538                                type: TemplateFieldType.FLOAT
539                        )
540                )
541                .with { if (!validate()) { errors.each { println it} } else save(flush:true)}
542                liverSamplingEventTemplate.refresh()
543
544                // blood sampling
545                println ".adding blood sampling event template"
546                def bloodSamplingEventTemplate = new Template(
547                        name: 'Blood extraction',
548                        description: 'Blood extraction targeted at lipid assays',
549                        entity: dbnp.studycapturing.SamplingEvent
550                )
551                .addToFields(samplingProtocolField)
552                .addToFields(
553                        new TemplateField(
554                                name: 'Sample volume',
555                                entity: SamplingEvent,
556                                unit: 'ml',
557                                type: TemplateFieldType.FLOAT
558                        )
559                )
560                .with { if (!validate()) { errors.each { println it} } else save(flush:true)}
561                bloodSamplingEventTemplate.refresh()
562
563                // plant sample extraction event template
564                println ".adding plant sample extraction event template"
565                def plantSamplingExtractEventTemplate = new Template(
566                        name: 'Plant sample extraction',
567                        description: 'sample extraction',
568                        entity: dbnp.studycapturing.SamplingEvent,
569                    sampleTemplates: [plantSampleTemplate]
570                )
571                .addToFields(samplingProtocolField)
572                .addToFields(
573                        new TemplateField(
574                                name: 'Sample weight',
575                                unit: 'ul',
576                                entity: SamplingEvent,
577                                type: TemplateFieldType.FLOAT
578                        )
579                )
580                .addToFields(
581                        new TemplateField(
582                                name: 'Sample when measured',
583                                type: TemplateFieldType.STRINGLIST,
584                                entity: SamplingEvent,
585                             listEntries: [
586                                         new TemplateFieldListItem(name:'Dried'),
587                             new TemplateFieldListItem(name: 'Fresh'),
588                             new TemplateFieldListItem(name: 'Unknown')
589                                 ]
590                        )
591                )
592                .with { if (!validate()) { errors.each { println it} } else save()}
593
594                // plant sampling event template
595                println ".adding plant sampling event template"
596                def plantSamplingEventTemplate = new Template(
597                        name: 'Plant-sample',
598                        description: 'plant sample ',
599                        entity: dbnp.studycapturing.SamplingEvent,
600                    sampleTemplates: [plantSampleTemplate]
601                )
602                //.addToFields(samplingProtocolField)
603                .addToFields(
604                        new TemplateField(
605                                name: 'material',
606                            comment: 'physical charecteristic. e.g, grounded powder of tomato seed or liquid',
607                                entity: SamplingEvent,
608                                type: TemplateFieldType.STRING
609                        )
610                )
611                .addToFields(
612                        new TemplateField(
613                                name: 'Description',
614                                type: TemplateFieldType.STRING,
615                                entity: SamplingEvent
616                        )
617                )
618                .addToFields(
619                        new TemplateField(
620                                name: 'extracted material',
621                                comment: 'substance to be extracted. e.g., lipids, volatiles, primary metabolites etc',
622                                type: TemplateFieldType.STRING,
623                                entity: SamplingEvent
624                        )
625                )
626                .addToFields(
627                        new TemplateField(
628                                name: 'Text on vial',
629                                entity: SamplingEvent,
630                                type: TemplateFieldType.STRING
631                        )
632                )
633                .with { if (!validate()) { errors.each { println it} } else save()}
634
635
636                // assay templates
637
638                def assayDescriptionField = new TemplateField(
639                                name: 'Description',
640                            comment: 'add general assay information here',
641                                entity: Assay,
642                                type: TemplateFieldType.STRING
643                );
644                assayDescriptionField.with { if (!validate()) { errors.each { println it} } else save()}
645
646                println ".adding clinical chemistry assay template"
647                def ccAssayTemplate = new Template(
648                        name: 'Clinical chemistry assay',
649                        description: 'Clinical chemistry assay stored in a SAM module',
650                        entity: dbnp.studycapturing.Assay
651                )
652                .addToFields(assayDescriptionField)
653                .with { if (!validate()) { errors.each { println it} } else save()}
654
655                println ".adding metabolomics assay template"
656                def metAssayTemplate = new Template(
657                        name: 'Metabolomics assay',
658                        description: 'Metabolomics assay stored in a metabolomics module',
659                        entity: dbnp.studycapturing.Assay
660                )
661                .addToFields(assayDescriptionField)
662                .addToFields(
663                        new TemplateField(
664                                name: 'Spectrometry technique',
665                            comment: 'Select the used metabolomics technique',
666                                entity: Assay,
667                                type: TemplateFieldType.STRINGLIST,
668                            listEntries: [
669                                        new TemplateFieldListItem(name: 'GC/MS'),
670                                new TemplateFieldListItem(name: 'LC/MS'),
671                                new TemplateFieldListItem(name: 'NMR'),
672                                new TemplateFieldListItem(name: 'HPLC')
673                            ])
674                )
675                .with { if (!validate()) { errors.each { println it} } else save(flush:true)}
676                metAssayTemplate.refresh()
677        }
678
679}
Note: See TracBrowser for help on using the repository browser.