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

Last change on this file since 1046 was 1046, checked in by m.s.vanvliet@…, 10 years ago

Update NMC Pilot pages

  • Property svn:keywords set to Author Date Rev
File size: 26.8 KB
Line 
1/**
2 * @Author kees
3 * @Since Jun 25, 2010
4 *
5 * Revision information:
6 * $Rev: 1046 $
7 * $Author: m.s.vanvliet@lacdr.leidenuniv.nl $
8 * $Date: 2010-11-02 09:25:06 +0000 (di, 02 nov 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                /*
233                 * Add NMC - DCL Sample Mapping Template
234                 * by Michael van Vliet
235                 *
236                 * For the Pilot running in Leiden (NOV2010)
237                 */
238                println ".adding sample DCL-Sample-Reference"
239                def sampleDCLTextField = new TemplateField(
240                        name: 'DCL Sample Reference',
241                        type: TemplateFieldType.STRING,
242                        entity: Sample
243                )
244                .with { if (!validate()) { errors.each { println it} } else save()}
245
246                // Human tissue sample template
247                println ".adding DCL Sample template..."
248                def dclSampleTemplate = new Template(
249                        name: 'DCL Sample information',
250                        entity: dbnp.studycapturing.Sample
251                )
252                .addToFields(sampleDCLTextField)
253                .with { if (!validate()) { errors.each { println it} } else save()}
254                // EO DCL Sample Mapping Template**********************************
255               
256               
257                /*
258                def GrowthTreatmentTemplate = new Template(
259                        name: 'Growth treatment',
260                        entity: dbnp.studycapturing.Event
261                )
262                .addToFields(sampleDescriptionField)
263                .addToFields(new TemplateField(name: 'position X',type: TemplateFieldType.STRING))
264                .addToFields(new TemplateField(name: 'position Y',type: TemplateFieldType.STRING))
265                .addToFields(new TemplateField(name: 'Block',type: TemplateFieldType.STRING))
266                .addToFields(new TemplateField(name: 'Temparature Day',type: TemplateFieldType.STRING))
267                .addToFields(new TemplateField(name: 'Temparature Night',type: TemplateFieldType.STRING))
268                .addToFields(new TemplateField(name: 'Light Intensity',type: TemplateFieldType.STRING))
269                .addToFields(new TemplateField(name: 'Harvest Delay',type: TemplateFieldType.STRING))
270                .with { if (!validate()) { errors.each { println it} } else save()}
271                 */
272
273                //Plant template
274                println ".adding geenhouse plant template..."
275                def greenHouseTemplate = new Template(
276                        name: 'Plant-green house ',
277                        entity: dbnp.studycapturing.Subject
278                )
279                .addToFields(varietyField)
280                .addToFields(ecotypeField)
281                 .addToFields(genotypeField)
282                /*
283                .addToFields(genotypeTypeField)
284                .addToFields(
285                        new TemplateField(
286                                name: 'Growth location', type: TemplateFieldType.STRINGLIST,
287                                listEntries: [
288                                        new TemplateFieldListItem(name:'Greenhouse'),
289                                        new TemplateFieldListItem(name: 'Field')
290                                ]
291                        )
292                )
293                .addToFields(
294                        new TemplateField(
295                                name: 'Room', type: TemplateFieldType.STRING,
296                                comment: 'Chamber number in case of Greenhouse'
297                        )
298                )
299                */
300                .addToFields(
301                        new TemplateField(
302                                name: 'Chamber no.',
303                                type: TemplateFieldType.STRING,
304                                entity: Subject,
305                                comment: 'Chamber number in the Greenhouse'
306                        )
307                )
308                .addToFields(
309                        new TemplateField(
310                                name: 'Growth type',
311                                entity: Subject,
312                                type: TemplateFieldType.STRINGLIST,
313                                listEntries: [
314                                        new TemplateFieldListItem(name:'Standard'),
315                                new TemplateFieldListItem(name: 'Experimental'),
316                                new TemplateFieldListItem(name: 'Unknown')
317                                ]
318                        )
319                )
320                .addToFields(new TemplateField(
321                        name: 'Growth protocol', entity: Subject, type: TemplateFieldType.TEXT))
322                .addToFields(new TemplateField(
323                        name: 'Position X', entity: Subject, type: TemplateFieldType.FLOAT))
324                .addToFields(new TemplateField(
325                        name: 'Position Y', entity: Subject, type: TemplateFieldType.FLOAT))
326                .addToFields(new TemplateField(
327                        name: 'Block', entity: Subject, type: TemplateFieldType.STRING))
328                .addToFields(new TemplateField(
329                        name: 'Temperature at day', entity: Subject, type: TemplateFieldType.FLOAT))
330                .addToFields(new TemplateField(
331                        name: 'Temperature at night', entity: Subject, type: TemplateFieldType.FLOAT))
332                .addToFields(new TemplateField(
333                        name: 'Photo period', entity: Subject, type: TemplateFieldType.STRING))
334                .addToFields(new TemplateField(
335                        name: 'Light intensity', entity: Subject, type: TemplateFieldType.STRING))
336                .addToFields(new TemplateField(
337                        name: 'Start date', entity: Subject, type: TemplateFieldType.DATE))
338                .addToFields(new TemplateField(
339                        name: 'Harvest date', entity: Subject, type: TemplateFieldType.DATE))
340                .addToFields(new TemplateField(
341                        name: 'Harvest delay', entity: Subject, type: TemplateFieldType.TEXT))
342                .addToFields(new TemplateField(
343                        name: 'Additional info', entity: Subject, type: TemplateFieldType.TEXT))
344                .with { if (!validate()) { errors.each { println it} } else save()}
345
346                println ".adding open-field plant template..."
347                def FieldTemplate = new Template(
348                        name: 'Plant-open field',
349                        entity: dbnp.studycapturing.Subject
350                )
351                .addToFields(varietyField)
352                .addToFields(ecotypeField)
353                .addToFields(genotypeField)
354                .addToFields(new TemplateField(
355                        name: 'Start date', entity: Subject, type: TemplateFieldType.DATE))
356                .addToFields(new TemplateField(
357                        name: 'Harvest date', entity: Subject, type: TemplateFieldType.DATE))
358                .addToFields(new TemplateField(
359                        name: 'Growth type', entity: Subject, type: TemplateFieldType.STRINGLIST,
360                        listEntries: [new TemplateFieldListItem(name:'Standard'),new TemplateFieldListItem(name: 'Experimental')]))
361                .addToFields(new TemplateField(
362                        name: 'Growth protocol', entity: Subject, type: TemplateFieldType.TEXT))
363                .addToFields(new TemplateField(
364                        name: 'Harvest delay', entity: Subject, type: TemplateFieldType.TEXT))
365                .with { if (!validate()) { errors.each { println it} } else save()}
366
367                //Plant template
368                println ".adding chamber plant template..."
369                def chamberTemplate = new Template(
370                        name: 'Plant-chamber',
371                        entity: dbnp.studycapturing.Subject
372                )
373                .addToFields(varietyField)
374                .addToFields(ecotypeField)
375                .addToFields(genotypeField)
376                /*
377                .addToFields(genotypeTypeField)
378                .addToFields(
379                        new TemplateField(
380                                name: 'Growth location',
381                                type: TemplateFieldType.STRINGLIST,
382                                listEntries: [
383                                        new TemplateFieldListItem(name:'Greenhouse'),
384                                        new TemplateFieldListItem(name: 'Field')
385                                ]
386                        )
387                )
388                */
389                .addToFields(new TemplateField(
390                        name: 'Room', type: TemplateFieldType.STRING, entity: Subject,
391                        comment: 'room number'))
392                .addToFields(new TemplateField(
393                        name: 'Chamber no.', type: TemplateFieldType.STRING, entity: Subject,
394                        comment: 'Chamber number'))
395                .addToFields(new TemplateField(
396                        name: 'Block', type: TemplateFieldType.STRING, entity: Subject))
397                .addToFields(new TemplateField(
398                        name: 'Position X', type: TemplateFieldType.FLOAT, entity: Subject))
399                .addToFields(new TemplateField(
400                        name: 'Position Y', type: TemplateFieldType.FLOAT, entity: Subject))
401                .addToFields(new TemplateField(
402                        name: 'Temperature at day', type: TemplateFieldType.FLOAT, entity: Subject))
403                .addToFields(new TemplateField(
404                        name: 'Temperature at night', type: TemplateFieldType.FLOAT, entity: Subject))
405                .addToFields(new TemplateField(
406                        name: 'Photo period', type: TemplateFieldType.STRING, entity: Subject))
407                .addToFields(new TemplateField(
408                        name: 'Light intensity', type: TemplateFieldType.STRING, entity: Subject))
409                .addToFields(new TemplateField(
410                        name: 'Start date', type: TemplateFieldType.DATE, entity: Subject))
411                .addToFields(new TemplateField(
412                        name: 'Harvest date', type: TemplateFieldType.DATE, entity: Subject))
413                .addToFields(new TemplateField(
414                        name: 'Growth type', type: TemplateFieldType.STRINGLIST, entity: Subject,
415                        listEntries: [new TemplateFieldListItem(name:'Standard'),new TemplateFieldListItem(name: 'Experimental')]))
416                .addToFields(new TemplateField(
417                        name: 'Growth protocol', type: TemplateFieldType.TEXT, entity: Subject))
418                .addToFields(new TemplateField(
419                        name: 'Harvest delay', type: TemplateFieldType.TEXT, entity: Subject))
420                .with { if (!validate()) { errors.each { println it} } else save()}
421
422                println ".adding plant sample template..."
423                def plantSampleTemplate = new Template(
424                        name: 'Plant sample',
425                        entity: dbnp.studycapturing.Sample
426                )
427                .addToFields(sampleRemarksField)
428                .addToFields(sampleVialTextField)
429                .with { if (!validate()) { errors.each { println it} } else save()}
430
431                println ".adding material prep template"
432                def materialPrepTemplate = new Template(
433                        name: 'Plant-material preparation',
434                    description: 'material preparation',
435                    entity: dbnp.studycapturing.Event
436                )
437                .addToFields(new TemplateField(
438                         name: 'Tissue',
439                        type: TemplateFieldType.STRING,
440                        entity: Event,
441                    comment: 'organ/ fraction of culture/ plant part')
442                )
443                .addToFields(
444                        new TemplateField(
445                                 name: 'Grinding',
446                                type: TemplateFieldType.STRINGLIST,
447                                entity: Event,
448                            listEntries: [
449                                        new TemplateFieldListItem(name:'yes'),
450                                new TemplateFieldListItem(name: 'no'),
451                                new TemplateFieldListItem(name: 'unknown')
452                                ]
453                        )
454                )
455                .addToFields(
456                        new TemplateField(
457                                name: 'Storage location',
458                                type: TemplateFieldType.STRING,
459                                entity: Event
460                        )
461                )
462                .addToFields(
463                        new TemplateField(
464                                name: 'protocol reference',
465                                type: TemplateFieldType.STRING,
466                                entity: Event
467                        )
468                )
469                .with { if (!validate()) { errors.each { println it} } else save()}
470
471                def protocolField = new TemplateField(
472                        name: 'Protocol',
473                        type: TemplateFieldType.FILE,
474                        entity: Event,
475                        comment: 'You can upload a protocol here which describes the procedure which was used when carrying out the event'
476                )
477                .with { if (!validate()) { errors.each { println it} } else save()}
478
479                // diet treatment template
480                println ".adding diet treatement template"
481                def dietTreatmentTemplate = new Template(
482                        name: 'Diet treatment',
483                        entity: dbnp.studycapturing.Event
484                )
485                .addToFields(
486                        new TemplateField(
487                                name: 'Diet',
488                                type: TemplateFieldType.STRINGLIST,
489                                entity: Event,
490                                listEntries: [
491                                        new TemplateFieldListItem(name:'low fat'),
492                                        new TemplateFieldListItem(name: 'high fat')
493                                ]
494                        )
495                )
496                .addToFields(protocolField)
497                .with { if (!validate()) { errors.each { println it} } else save(flush:true)}
498                dietTreatmentTemplate.refresh()
499
500                // boost treatment template
501                println ".adding boost treatment template"
502                def boostTreatmentTemplate = new Template(
503                        name: 'Compound challenge',
504                        entity: dbnp.studycapturing.Event
505                )
506                .addToFields(
507                        new TemplateField(
508                                name: 'Compound',
509                                type: TemplateFieldType.ONTOLOGYTERM,
510                                entity: Event,
511                                ontologies: [Ontology.getOrCreateOntologyByNcboId(1007)]
512                        )
513                )
514                .addToFields(
515                        new TemplateField(
516                                name: 'Control',
517                                type: TemplateFieldType.BOOLEAN,
518                                entity: Event
519                        )
520                )
521                .addToFields(protocolField)
522                .with { if (!validate()) { errors.each { println it} } else save(flush:true)}
523                boostTreatmentTemplate.refresh()
524
525                // fasting treatment template
526                println ".adding fasting treatment template"
527                def fastingTreatment = new Template(
528                        name: 'Fasting treatment',
529                        description: 'Fasting for a specific amount of time',
530                        entity: dbnp.studycapturing.Event
531                )
532                .addToFields(
533                        new TemplateField(
534                                name: 'Fasting period',
535                                type: TemplateFieldType.RELTIME,
536                                entity: Event
537                        )
538                )
539                .with { if (!validate()) { errors.each { println it} } else save()}
540
541                // SamplingEvent templates
542                println ".adding sampling protocol template field"
543                def samplingProtocolField = new TemplateField(
544                        name: 'Sample Protocol',
545                        entity: SamplingEvent,
546                        type: TemplateFieldType.FILE,
547                        comment: 'You can upload a protocol here which describes the procedure which was used when carrying out the sampling event'
548                )
549                .with { if (!validate()) { errors.each { println it} } else save()}
550
551                // liver sampling event template
552                println ".adding liver sampling event template"
553                def liverSamplingEventTemplate = new Template(
554                        name: 'Liver extraction',
555                        description: 'Liver sampling for transcriptomics arrays',
556                        entity: dbnp.studycapturing.SamplingEvent
557                )
558                .addToFields(samplingProtocolField)
559                .addToFields(
560                        new TemplateField(
561                                name: 'Sample weight',
562                                unit: 'mg',
563                                entity: SamplingEvent,
564                                type: TemplateFieldType.FLOAT
565                        )
566                )
567                .with { if (!validate()) { errors.each { println it} } else save(flush:true)}
568                liverSamplingEventTemplate.refresh()
569
570                // blood sampling
571                println ".adding blood sampling event template"
572                def bloodSamplingEventTemplate = new Template(
573                        name: 'Blood extraction',
574                        description: 'Blood extraction targeted at lipid assays',
575                        entity: dbnp.studycapturing.SamplingEvent
576                )
577                .addToFields(samplingProtocolField)
578                .addToFields(
579                        new TemplateField(
580                                name: 'Sample volume',
581                                entity: SamplingEvent,
582                                unit: 'ml',
583                                type: TemplateFieldType.FLOAT
584                        )
585                )
586                .with { if (!validate()) { errors.each { println it} } else save(flush:true)}
587                bloodSamplingEventTemplate.refresh()
588
589                // plant sample extraction event template
590                println ".adding plant sample extraction event template"
591                def plantSamplingExtractEventTemplate = new Template(
592                        name: 'Plant sample extraction',
593                        description: 'sample extraction',
594                        entity: dbnp.studycapturing.SamplingEvent,
595                    sampleTemplates: [plantSampleTemplate]
596                )
597                .addToFields(samplingProtocolField)
598                .addToFields(
599                        new TemplateField(
600                                name: 'Sample weight',
601                                unit: 'ul',
602                                entity: SamplingEvent,
603                                type: TemplateFieldType.FLOAT
604                        )
605                )
606                .addToFields(
607                        new TemplateField(
608                                name: 'Sample when measured',
609                                type: TemplateFieldType.STRINGLIST,
610                                entity: SamplingEvent,
611                             listEntries: [
612                                         new TemplateFieldListItem(name:'Dried'),
613                             new TemplateFieldListItem(name: 'Fresh'),
614                             new TemplateFieldListItem(name: 'Unknown')
615                                 ]
616                        )
617                )
618                .with { if (!validate()) { errors.each { println it} } else save()}
619
620                // plant sampling event template
621                println ".adding plant sampling event template"
622                def plantSamplingEventTemplate = new Template(
623                        name: 'Plant-sample',
624                        description: 'plant sample ',
625                        entity: dbnp.studycapturing.SamplingEvent,
626                    sampleTemplates: [plantSampleTemplate]
627                )
628                //.addToFields(samplingProtocolField)
629                .addToFields(
630                        new TemplateField(
631                                name: 'material',
632                            comment: 'physical charecteristic. e.g, grounded powder of tomato seed or liquid',
633                                entity: SamplingEvent,
634                                type: TemplateFieldType.STRING
635                        )
636                )
637                .addToFields(
638                        new TemplateField(
639                                name: 'Description',
640                                type: TemplateFieldType.STRING,
641                                entity: SamplingEvent
642                        )
643                )
644                .addToFields(
645                        new TemplateField(
646                                name: 'extracted material',
647                                comment: 'substance to be extracted. e.g., lipids, volatiles, primary metabolites etc',
648                                type: TemplateFieldType.STRING,
649                                entity: SamplingEvent
650                        )
651                )
652                .addToFields(
653                        new TemplateField(
654                                name: 'Text on vial',
655                                entity: SamplingEvent,
656                                type: TemplateFieldType.STRING
657                        )
658                )
659                .with { if (!validate()) { errors.each { println it} } else save()}
660
661
662                // assay templates
663
664                def assayDescriptionField = new TemplateField(
665                                name: 'Description',
666                            comment: 'add general assay information here',
667                                entity: Assay,
668                                type: TemplateFieldType.STRING
669                );
670                assayDescriptionField.with { if (!validate()) { errors.each { println it} } else save()}
671
672                println ".adding clinical chemistry assay template"
673                def ccAssayTemplate = new Template(
674                        name: 'Clinical chemistry assay',
675                        description: 'Clinical chemistry assay stored in a SAM module',
676                        entity: dbnp.studycapturing.Assay
677                )
678                .addToFields(assayDescriptionField)
679                .with { if (!validate()) { errors.each { println it} } else save()}
680
681                println ".adding metabolomics assay template"
682                def metAssayTemplate = new Template(
683                        name: 'Metabolomics assay',
684                        description: 'Metabolomics assay stored in a metabolomics module',
685                        entity: dbnp.studycapturing.Assay
686                )
687                .addToFields(assayDescriptionField)
688                .addToFields(
689                        new TemplateField(
690                                name: 'Spectrometry technique',
691                            comment: 'Select the used metabolomics technique',
692                                entity: Assay,
693                                type: TemplateFieldType.STRINGLIST,
694                            listEntries: [
695                                        new TemplateFieldListItem(name: 'GC/MS'),
696                                new TemplateFieldListItem(name: 'LC/MS'),
697                                new TemplateFieldListItem(name: 'NMR'),
698                                new TemplateFieldListItem(name: 'HPLC')
699                            ])
700                )
701                .with { if (!validate()) { errors.each { println it} } else save(flush:true)}
702                metAssayTemplate.refresh()
703        }
704
705}
Note: See TracBrowser for help on using the repository browser.