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

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