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

Last change on this file since 1153 was 1153, checked in by robert@…, 10 years ago

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