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

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