root/trunk/grails-app/conf/dbnp/configuration/ExampleTemplates.groovy @ 1547

Revision 1547, 26.4 KB (checked in by work@…, 3 years ago)

- renamed bootstraps to example

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