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

Last change on this file since 1366 was 1341, checked in by business@…, 10 years ago

fix for development environment to circumvent BioPortal? problems

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