Changeset 626

Show
Ignore:
Timestamp:
25-06-10 16:03:14 (4 years ago)
Author:
keesvb
Message:

removed example templates and studies from BootStrap? to separate files

Location:
trunk/grails-app/conf
Files:
2 added
1 modified

Legend:

Unmodified
Added
Removed
  • trunk/grails-app/conf/BootStrap.groovy

    r616 r626  
    1717 */ 
    1818class BootStrap { 
    19         def init = { servletContext -> 
     19        def init = {servletContext -> 
    2020                // define timezone 
    2121                System.setProperty('user.timezone', 'CET') 
    2222 
    23                 // production bootstrapping 
    24                 if (GrailsUtil.environment == "production" && Template.count() == 0) { 
    25                         println ".production bootstrapping..." 
    26  
    27                         // TODO, initial application templates, terms and ontologies 
    28                 } 
    29  
    30                 // development bootstrapping 
    31                 if (GrailsUtil.environment == GrailsApplication.ENV_DEVELOPMENT && Study.count() == 0 && false) { 
    32                         println ".development bootstrapping..." 
    33  
    34                         // add Subject>species ontology 
    35                         println ".adding NCBI species ontology" 
    36                         def speciesOntology = new Ontology( 
    37                                 name: 'NCBI organismal classification', 
    38                                 description: 'A taxonomic classification of living organisms and associated artifacts for their controlled description within the context of databases.', 
    39                                 url: 'http://www.ncbi.nlm.nih.gov/Taxonomy/taxonomyhome.html/', 
    40                                 versionNumber: '1.2', 
    41                                 ncboId: '1132', 
    42                                 ncboVersionedId: '38802' 
    43                         ).with { if (!validate()) { errors.each { println it} } else save()} 
    44  
    45                         // add Sample>material ontology 
    46                         println ".adding BRENDA source material ontology" 
    47                         def brendaOntology = new Ontology( 
    48                                 name: 'BRENDA tissue / enzyme source', 
    49                                 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.', 
    50                                 url: 'http://www.brenda-enzymes.info', 
    51                                 versionNumber: '1.3', 
    52                                 ncboId: '1005', 
    53                                 ncboVersionedId: '40643' 
    54                         ).with { if (!validate()) { errors.each { println it} } else save()} 
    55  
    56                         // add NCI ontology which is used in Mouse genotype template field 
    57                         def nciOntology = new Ontology( 
    58                                 name: 'NCI Thesaurus', 
    59                                 description: 'A vocabulary for clinical care, translational and basic research, and public information and administrative activities.', 
    60                                 url: 'http://ncicb.nci.nih.gov/core/EVS', 
    61                                 versionNumber: '10.01', 
    62                                 ncboId: '1032', 
    63                                 ncboVersionedId: '42693' 
    64                         ).with { if (!validate()) { errors.each { println it} } else save()} 
    65  
    66                         // add CHEBI ontology which is used in Mouse genotype template field 
    67                         def chebiOntology = new Ontology( 
    68                                 name: 'Chemical entities of biological interest', 
    69                                 description: 'A structured classification of chemical compounds of biological relevance.', 
    70                                 url: 'http://www.ebi.ac.uk/chebi', 
    71                                 versionNumber: '1.68', 
    72                                 ncboId: '1007', 
    73                                 ncboVersionedId: '42878' 
    74                         ).with { if (!validate()) { errors.each { println it} } else save()} 
    75  
    76                         // add Terms 
    77                         println ".adding terms" 
    78                         def mouseTerm = new Term( 
    79                                 name: 'Mus musculus', 
    80                                 ontology: speciesOntology, 
    81                                 accession: '10090' 
    82                         ).with { if (!validate()) { errors.each { println it} } else save()} 
    83  
    84                         def humanTerm = new Term( 
    85                                 name: 'Homo sapiens', 
    86                                 ontology: speciesOntology, 
    87                                 accession: '9606' 
    88                         ).with { if (!validate()) { errors.each { println it} } else save()} 
    89  
    90                 def arabTerm = new Term( 
    91                                 name: 'Arabidopsis thaliana', 
    92                                 ontology: speciesOntology, 
    93                                 accession: '3702' 
    94                         ).with { if (!validate()) { errors.each { println it} } else save()} 
    95  
    96                 def tomatoTerm = new Term( 
    97                                 name: 'Solanum lycopersicum', 
    98                                 ontology: speciesOntology, 
    99                                 accession: '4081' 
    100                         ).with { if (!validate()) { errors.each { println it} } else save()} 
    101  
    102                 def potatoTerm = new Term( 
    103                                 name: 'Solanum tuberosum', 
    104                                 ontology: speciesOntology, 
    105                                 accession: '0000' 
    106                         ).with { if (!validate()) { errors.each { println it} } else save()} 
    107  
    108                         def bloodTerm = new Term( 
    109                                 name: 'blood plasma', 
    110                                 ontology: brendaOntology, 
    111                                 accession: 'BTO:0000131' 
    112                         ).with { if (!validate()) { errors.each { println it} } else save()} 
    113  
    114                         def c57bl6Term = new Term( 
    115                                 name: 'C57BL/6 Mouse', 
    116                                 ontology: nciOntology, 
    117                                 accession: 'C14424' 
    118                         ).with { if (!validate()) { errors.each { println it} } else save()} 
    119  
    120                         def glucoseTerm = new Term( 
    121                                 name: 'Glucose', 
    122                                 ontology: chebiOntology, 
    123                                 accession: 'CHEBI:17234' 
    124                         ).with { if (!validate()) { errors.each { println it} } else save()} 
    125  
    126  
    127             // Create templates 
    128                         println ".adding templates" 
    129  
    130                         def genderField = new TemplateField( 
    131                                 name: 'Gender',type: TemplateFieldType.STRINGLIST, entity: Subject, 
    132                                 listEntries: [new TemplateFieldListItem(name:'Male'),new TemplateFieldListItem(name: 'Female'),new TemplateFieldListItem(name: 'Unknown')]) 
    133                         .with { if (!validate()) { errors.each { println it} } else save()} 
    134  
    135                         def ageField = new TemplateField( 
    136                                 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)') 
    137                         .with { if (!validate()) { errors.each { println it} } else save()} 
    138  
    139                         def genotypeField = new TemplateField( 
    140                                 name: 'Genotype', type: TemplateFieldType.STRING,entity: Subject, 
    141                                 comment: 'If present, indicate the genetic variance of the subject (e.g., mutagenized populations,knock-out/in,transgene etc)') 
    142                         .with { if (!validate()) { errors.each { println it} } else save()} 
    143  
    144                 def genotypeTypeField = new TemplateField( 
    145                                 name: 'Genotype type',type: TemplateFieldType.STRINGLIST,entity: Subject, 
    146                                 listEntries: [new TemplateFieldListItem(name:'wildtype'), 
    147                                         new TemplateFieldListItem(name:'transgenic'), 
    148                                         new TemplateFieldListItem(name:'knock-out'), 
    149                                         new TemplateFieldListItem(name:'knock-in')], 
    150                                 comment: 'If a genotype was specified, please indicate here the type of the genotype')   
    151                         .with { if (!validate()) { errors.each { println it} } else save()} 
    152  
    153                 def varietyField = new TemplateField( 
    154                                 name: 'Variety', type: TemplateFieldType.STRING,entity: Subject, 
    155                         comment: 'taxonomic category consisting of members of a species that differ from others of the same species in minor but heritable characteristics') 
    156                         .with { if (!validate()) { errors.each { println it} } else save()} 
    157  
    158                         def ecotypeField = new TemplateField( 
    159                         name: 'Ecotype', type: TemplateFieldType.STRING,entity: Subject, 
    160                         comment: 'a type or subspecies of life that is especially well adapted to a certain environment' 
    161                         ) 
    162                 .with { if (!validate()) { errors.each { println it} } else save()} 
    163  
    164  
    165                 // Nutritional study template 
    166                         println ".adding academic study template..." 
    167                         def studyTemplate = new Template( 
    168                                 name: 'Academic study', 
    169                                 entity: dbnp.studycapturing.Study 
    170                         ) 
    171                         .addToFields(new TemplateField(name: 'Description',type: TemplateFieldType.TEXT, entity: Study,comment:'Describe here the type of subjects and the treatment, challenges and sampling.')) 
    172                         .addToFields(new TemplateField(name: 'Objectives',type: TemplateFieldType.TEXT,entity: Study,comment:'Fill out the aim or questions of the study')) 
    173                         .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')) 
    174                         .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)')) 
    175                         .addToFields(new TemplateField(name: 'Lab id',type: TemplateFieldType.STRING,entity: Study,comment:'In which lab was the study performed; indicate the roomnumber.')) 
    176                         .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?)')) 
    177                         .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')) 
    178                         .with { if (!validate()) { errors.each { println it} } else save()} 
    179  
    180                         // Mouse template 
    181                         println ".adding mouse subject template..." 
    182                         def mouseTemplate = new Template( 
    183                                 name: 'Mouse', entity: dbnp.studycapturing.Subject) 
    184                         .addToFields(new TemplateField( 
    185                                 name: 'Strain', type: TemplateFieldType.ONTOLOGYTERM, ontologies: [nciOntology], entity: Subject, comment: "This is an ontology term, if the right strain is not in the list please add it with 'add more'")) 
    186                         .addToFields(genotypeField) 
    187                         .addToFields(genotypeTypeField) 
    188                         .addToFields(genderField) 
    189                         .addToFields(new TemplateField( 
    190                                 name: 'Age', type: TemplateFieldType.INTEGER, entity: Subject, unit: 'weeks', comment: 'Age at start of study')) 
    191                         .addToFields(new TemplateField( 
    192                                 name: 'Age type',type: TemplateFieldType.STRINGLIST,entity: Subject, 
    193                                 listEntries: [new TemplateFieldListItem(name:'postnatal'),new TemplateFieldListItem(name:'embryonal')])) 
    194                         .addToFields(new TemplateField( 
    195                                 name: 'Cage',type: TemplateFieldType.STRING,entity: Subject,comment:'Indicate the cage used for housing (type and/or size)')) 
    196                         .addToFields(new TemplateField( 
    197                                 name: '#Mice in cage',type: TemplateFieldType.INTEGER,entity: Subject,comment:'If known, indicate the number of mice per cage')) 
    198                         .addToFields(new TemplateField( 
    199                                 name: 'Litter size',type: TemplateFieldType.INTEGER,entity: Subject,comment:'If known, indicate the litter size of the litter from which the subject originates')) 
    200                         .addToFields(new TemplateField( 
    201                                 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')) 
    202                         .with { if (!validate()) { errors.each { println it} } else save()} 
    203  
    204                         // Human template 
    205                         println ".adding human subject template..." 
    206                         def humanTemplate = new Template( 
    207                                 name: 'Human', entity: dbnp.studycapturing.Subject) 
    208                         .addToFields(genderField) 
    209                         .addToFields(ageField) 
    210                         .addToFields(new TemplateField( 
    211                                 name: 'DOB',type: TemplateFieldType.DATE,entity: Subject,comment:'Date of birth')) 
    212                         .addToFields(new TemplateField( 
    213                                 name: 'Height',type: TemplateFieldType.DOUBLE, entity: Subject, unit: 'm')) 
    214                         .addToFields(new TemplateField( 
    215                                 name: 'Weight',type: TemplateFieldType.DOUBLE, entity: Subject, unit: 'kg')) 
    216                         .addToFields(new TemplateField( 
    217                                 name: 'BMI',type: TemplateFieldType.DOUBLE, entity: Subject, unit: 'kg/m2',comment:'Body-mass-index')) 
    218                         .addToFields(new TemplateField( 
    219                                 name: 'Race',type: TemplateFieldType.STRING,entity: Subject, comment:'If known and of interest the ethnic group can be indicated')) 
    220                         .addToFields(new TemplateField( 
    221                                 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.')) 
    222                         .addToFields(new TemplateField( 
    223                                 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.')) 
    224                         .addToFields(new TemplateField( 
    225                                 name: 'Systolic blood pressure',type: TemplateFieldType.FLOAT, unit: 'mmHg',entity: Subject, comment:'Indicate the levels at the start of the study in mmHG')) 
    226                         .addToFields(new TemplateField( 
    227                                 name: 'Diastolic blood pressure',type: TemplateFieldType.FLOAT, unit: 'mmHg',entity: Subject, comment:'Indicate the levels at the start of the study in mmHG')) 
    228                         .addToFields(new TemplateField( 
    229                                 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')) 
    230                         .addToFields(new TemplateField( 
    231                                 name: 'Run-in-food',type: TemplateFieldType.TEXT,entity: Subject, comment:'If defined, give a short description of the food used before the measurements')) 
    232                         .with { if (!validate()) { errors.each { println it} } else save()} 
    233  
    234                         println ".adding sample remarks field" 
    235                         def sampleRemarksField = new TemplateField( 
    236                                 name: 'Remarks', 
    237                                 type: TemplateFieldType.TEXT, 
    238                 entity: Sample 
    239                         ) 
    240                         .with { if (!validate()) { errors.each { println it} } else save()} 
    241  
    242                         println ".adding sample vial textfield" 
    243                         def sampleVialTextField = new TemplateField( 
    244                                 name: 'Text on vial', 
    245                                 type: TemplateFieldType.STRING, 
    246                 entity: Sample 
    247                         ) 
    248                         .with { if (!validate()) { errors.each { println it} } else save()} 
    249  
    250                         // Human tissue sample template 
    251                         println ".adding human sample template..." 
    252                         def humanSampleTemplate = new Template( 
    253                                 name: 'Human tissue sample', 
    254                                 entity: dbnp.studycapturing.Sample 
    255                         ) 
    256                         .addToFields(sampleRemarksField) 
    257                         .addToFields(sampleVialTextField) 
    258             .addToFields( 
    259                                 new TemplateField( 
    260                         name: 'Sample measured weight', 
    261                         unit: 'mg', 
    262                         type: TemplateFieldType.FLOAT, 
    263                     entity: Sample 
    264                                 ) 
    265                         ) 
    266                         .with { if (!validate()) { errors.each { println it} } else save()} 
    267  
    268             // Human blood sample template 
    269             println ".adding human sample template..." 
    270             def humanBloodSampleTemplate = new Template( 
    271                 name: 'Human blood sample', 
    272                                 entity: dbnp.studycapturing.Sample 
    273                         ) 
    274             .addToFields(sampleRemarksField) 
    275             .addToFields(sampleVialTextField) 
    276             .addToFields( 
    277                                 new TemplateField( 
    278                         name: 'Sample measured volume', 
    279                         unit: 'ml', 
    280                         type: TemplateFieldType.FLOAT, 
    281                                         entity: Sample 
    282                                 ) 
    283                         ) 
    284             .with { if (!validate()) { errors.each { println it} } else save()} 
    285  
    286                 /* 
    287             def GrowthTreatmentTemplate = new Template( 
    288                                 name: 'Growth treatment', 
    289                                 entity: dbnp.studycapturing.Event 
    290                         ) 
    291                         .addToFields(sampleDescriptionField) 
    292                         .addToFields(new TemplateField(name: 'position X',type: TemplateFieldType.STRING)) 
    293             .addToFields(new TemplateField(name: 'position Y',type: TemplateFieldType.STRING)) 
    294             .addToFields(new TemplateField(name: 'Block',type: TemplateFieldType.STRING)) 
    295             .addToFields(new TemplateField(name: 'Temparature Day',type: TemplateFieldType.STRING)) 
    296             .addToFields(new TemplateField(name: 'Temparature Night',type: TemplateFieldType.STRING)) 
    297             .addToFields(new TemplateField(name: 'Light Intensity',type: TemplateFieldType.STRING)) 
    298             .addToFields(new TemplateField(name: 'Harvest Delay',type: TemplateFieldType.STRING)) 
    299             .with { if (!validate()) { errors.each { println it} } else save()} 
    300                 */ 
    301  
    302                         //Plant template 
    303                         println ".adding geenhouse plant template..." 
    304                         def greenHouseTemplate = new Template( 
    305                                 name: 'Plant-green house ', 
    306                                 entity: dbnp.studycapturing.Subject 
    307                         ) 
    308                         .addToFields(varietyField) 
    309                 .addToFields(ecotypeField) 
    310                 .addToFields(genotypeField) 
    311             /* 
    312                         .addToFields(genotypeTypeField) 
    313                         .addToFields( 
    314                                 new TemplateField( 
    315                                         name: 'Growth location', type: TemplateFieldType.STRINGLIST, 
    316                                         listEntries: [ 
    317                                                 new TemplateFieldListItem(name:'Greenhouse'), 
    318                                                 new TemplateFieldListItem(name: 'Field') 
    319                                         ] 
    320                                 ) 
    321                         ) 
    322                         .addToFields( 
    323                                 new TemplateField( 
    324                                         name: 'Room', type: TemplateFieldType.STRING, 
    325                                         comment: 'Chamber number in case of Greenhouse' 
    326                                 ) 
    327                         ) 
    328             */ 
    329                 .addToFields( 
    330                                 new TemplateField( 
    331                                         name: 'Chamber no.', 
    332                                         type: TemplateFieldType.STRING, 
    333                                         entity: Subject, 
    334                                         comment: 'Chamber number in the Greenhouse' 
    335                                 ) 
    336                         ) 
    337                 .addToFields( 
    338                                 new TemplateField( 
    339                                         name: 'Growth type', 
    340                                         entity: Subject, 
    341                                         type: TemplateFieldType.STRINGLIST, 
    342                                         listEntries: [ 
    343                                                 new TemplateFieldListItem(name:'Standard'), 
    344                         new TemplateFieldListItem(name: 'Experimental'), 
    345                         new TemplateFieldListItem(name: 'Unknown') 
    346                                         ] 
    347                                 ) 
    348                         ) 
    349                         .addToFields(new TemplateField( 
    350                                 name: 'Growth protocol', entity: Subject, type: TemplateFieldType.TEXT)) 
    351                 .addToFields(new TemplateField( 
    352                                 name: 'Position X', entity: Subject, type: TemplateFieldType.FLOAT)) 
    353                         .addToFields(new TemplateField( 
    354                                 name: 'Position Y', entity: Subject, type: TemplateFieldType.FLOAT)) 
    355                         .addToFields(new TemplateField( 
    356                                 name: 'Block', entity: Subject, type: TemplateFieldType.STRING)) 
    357                         .addToFields(new TemplateField( 
    358                                 name: 'Temperature at day', entity: Subject, type: TemplateFieldType.FLOAT)) 
    359                         .addToFields(new TemplateField( 
    360                                 name: 'Temperature at night', entity: Subject, type: TemplateFieldType.FLOAT)) 
    361                         .addToFields(new TemplateField( 
    362                                 name: 'Photo period', entity: Subject, type: TemplateFieldType.STRING)) 
    363                         .addToFields(new TemplateField( 
    364                                 name: 'Light intensity', entity: Subject, type: TemplateFieldType.STRING)) 
    365                         .addToFields(new TemplateField( 
    366                                 name: 'Start date', entity: Subject, type: TemplateFieldType.DATE)) 
    367                         .addToFields(new TemplateField( 
    368                                 name: 'Harvest date', entity: Subject, type: TemplateFieldType.DATE)) 
    369                         .addToFields(new TemplateField( 
    370                                 name: 'Harvest delay', entity: Subject, type: TemplateFieldType.TEXT)) 
    371                         .addToFields(new TemplateField( 
    372                                 name: 'Additional info', entity: Subject, type: TemplateFieldType.TEXT)) 
    373                 .with { if (!validate()) { errors.each { println it} } else save()} 
    374  
    375             println ".adding open-field plant template..." 
    376                         def FieldTemplate = new Template( 
    377                                 name: 'Plant-open field', 
    378                                 entity: dbnp.studycapturing.Subject 
    379                         ) 
    380                         .addToFields(varietyField) 
    381                         .addToFields(ecotypeField) 
    382                         .addToFields(genotypeField) 
    383             .addToFields(new TemplateField( 
    384                                 name: 'Start date', entity: Subject, type: TemplateFieldType.DATE)) 
    385                         .addToFields(new TemplateField( 
    386                                 name: 'Harvest date', entity: Subject, type: TemplateFieldType.DATE)) 
    387                         .addToFields(new TemplateField( 
    388                                 name: 'Growth type', entity: Subject, type: TemplateFieldType.STRINGLIST, 
    389                                 listEntries: [new TemplateFieldListItem(name:'Standard'),new TemplateFieldListItem(name: 'Experimental')])) 
    390                         .addToFields(new TemplateField( 
    391                                 name: 'Growth protocol', entity: Subject, type: TemplateFieldType.TEXT)) 
    392                         .addToFields(new TemplateField( 
    393                                 name: 'Harvest delay', entity: Subject, type: TemplateFieldType.TEXT)) 
    394                 .with { if (!validate()) { errors.each { println it} } else save()} 
    395  
    396             //Plant template 
    397                         println ".adding chamber plant template..." 
    398                         def chamberTemplate = new Template( 
    399                                 name: 'Plant-chamber', 
    400                                 entity: dbnp.studycapturing.Subject 
    401                         ) 
    402                         .addToFields(varietyField) 
    403             .addToFields(ecotypeField) 
    404             .addToFields(genotypeField) 
    405                         /* 
    406                         .addToFields(genotypeTypeField) 
    407                         .addToFields( 
    408                                 new TemplateField( 
    409                                         name: 'Growth location', 
    410                                         type: TemplateFieldType.STRINGLIST, 
    411                                         listEntries: [ 
    412                                                 new TemplateFieldListItem(name:'Greenhouse'), 
    413                                                 new TemplateFieldListItem(name: 'Field') 
    414                                         ] 
    415                                 ) 
    416                         ) 
    417                         */ 
    418                         .addToFields(new TemplateField( 
    419                                 name: 'Room', type: TemplateFieldType.STRING, entity: Subject, 
    420                                 comment: 'room number')) 
    421                         .addToFields(new TemplateField( 
    422                                 name: 'Chamber no.', type: TemplateFieldType.STRING, entity: Subject, 
    423                                 comment: 'Chamber number')) 
    424                         .addToFields(new TemplateField( 
    425                                 name: 'Block', type: TemplateFieldType.STRING, entity: Subject)) 
    426                         .addToFields(new TemplateField( 
    427                                 name: 'Position X', type: TemplateFieldType.FLOAT, entity: Subject)) 
    428                         .addToFields(new TemplateField( 
    429                                 name: 'Position Y', type: TemplateFieldType.FLOAT, entity: Subject)) 
    430                         .addToFields(new TemplateField( 
    431                                 name: 'Temperature at day', type: TemplateFieldType.FLOAT, entity: Subject)) 
    432                         .addToFields(new TemplateField( 
    433                                 name: 'Temperature at night', type: TemplateFieldType.FLOAT, entity: Subject)) 
    434                         .addToFields(new TemplateField( 
    435                                 name: 'Photo period', type: TemplateFieldType.STRING, entity: Subject)) 
    436                         .addToFields(new TemplateField( 
    437                                 name: 'Light intensity', type: TemplateFieldType.STRING, entity: Subject)) 
    438                         .addToFields(new TemplateField( 
    439                                 name: 'Start date', type: TemplateFieldType.DATE, entity: Subject)) 
    440                         .addToFields(new TemplateField( 
    441                                 name: 'Harvest date', type: TemplateFieldType.DATE, entity: Subject)) 
    442                         .addToFields(new TemplateField( 
    443                                 name: 'Growth type', type: TemplateFieldType.STRINGLIST, entity: Subject, 
    444                                 listEntries: [new TemplateFieldListItem(name:'Standard'),new TemplateFieldListItem(name: 'Experimental')])) 
    445                         .addToFields(new TemplateField( 
    446                                 name: 'Growth protocol', type: TemplateFieldType.TEXT, entity: Subject)) 
    447                         .addToFields(new TemplateField( 
    448                                 name: 'Harvest delay', type: TemplateFieldType.TEXT, entity: Subject)) 
    449                         .with { if (!validate()) { errors.each { println it} } else save()} 
    450  
    451                         println ".adding plant sample template..." 
    452                         def plantSampleTemplate = new Template( 
    453                                 name: 'Plant sample', 
    454                                 entity: dbnp.studycapturing.Sample 
    455                         ) 
    456                         .addToFields(sampleRemarksField) 
    457                         .addToFields(sampleVialTextField) 
    458                         .with { if (!validate()) { errors.each { println it} } else save()} 
    459  
    460                         println ".adding material prep template" 
    461                         def materialPrepTemplate = new Template( 
    462                                 name: 'Plant-material preparation', 
    463                 description: 'material preparation', 
    464                 entity: dbnp.studycapturing.Event 
    465                         ) 
    466                         .addToFields(new TemplateField( 
    467                                 name: 'Tissue', 
    468                                 type: TemplateFieldType.STRING, 
    469                                 entity: Event, 
    470                 comment: 'organ/ fraction of culture/ plant part') 
    471                         ) 
    472             .addToFields( 
    473                                 new TemplateField( 
    474                                         name: 'Grinding', 
    475                                         type: TemplateFieldType.STRINGLIST, 
    476                                         entity: Event, 
    477                         listEntries: [ 
    478                                                 new TemplateFieldListItem(name:'yes'), 
    479                             new TemplateFieldListItem(name: 'no'), 
    480                             new TemplateFieldListItem(name: 'unknown') 
    481                                         ] 
    482                                 ) 
    483                         ) 
    484                         .addToFields( 
    485                                 new TemplateField( 
    486                                         name: 'Storage location', 
    487                                         type: TemplateFieldType.STRING, 
    488                                         entity: Event 
    489                                 ) 
    490                         ) 
    491                         .addToFields( 
    492                                 new TemplateField( 
    493                                         name: 'protocol reference', 
    494                                         type: TemplateFieldType.STRING, 
    495                                         entity: Event 
    496                                 ) 
    497                         ) 
    498                         .with { if (!validate()) { errors.each { println it} } else save()} 
    499  
    500                         def protocolField = new TemplateField( 
    501                                 name: 'Protocol', 
    502                                 type: TemplateFieldType.FILE, 
    503                                 entity: Event, 
    504                                 comment: 'You can upload a protocol here which describes the procedure which was used when carrying out the event' 
    505                         ) 
    506                         .with { if (!validate()) { errors.each { println it} } else save()} 
    507  
    508                         // diet treatment template 
    509                         println ".adding diet treatement template" 
    510                         def dietTreatmentTemplate = new Template( 
    511                                 name: 'Diet treatment', 
    512                                 entity: dbnp.studycapturing.Event 
    513                         ) 
    514                         .addToFields( 
    515                                 new TemplateField( 
    516                                         name: 'Diet', 
    517                                         type: TemplateFieldType.STRINGLIST, 
    518                                         entity: Event, 
    519                                         listEntries: [ 
    520                                                 new TemplateFieldListItem(name:'low fat'), 
    521                                                 new TemplateFieldListItem(name: 'high fat') 
    522                                         ] 
    523                                 ) 
    524                         ) 
    525                         .addToFields(protocolField) 
    526                         .with { if (!validate()) { errors.each { println it} } else save()} 
    527  
    528                         // boost treatment template 
    529                         println ".adding boost treatment template" 
    530                         def boostTreatmentTemplate = new Template( 
    531                                 name: 'Compound challenge', 
    532                                 entity: dbnp.studycapturing.Event 
    533                         ) 
    534                         .addToFields( 
    535                                 new TemplateField( 
    536                                         name: 'Compound', 
    537                                         type: TemplateFieldType.ONTOLOGYTERM, 
    538                                         entity: Event, 
    539                                         ontologies: [chebiOntology] 
    540                                 ) 
    541                         ) 
    542                         .addToFields( 
    543                                 new TemplateField( 
    544                                         name: 'Control', 
    545                                         type: TemplateFieldType.BOOLEAN, 
    546                                         entity: Event 
    547                                 ) 
    548                         ) 
    549                         .addToFields(protocolField) 
    550                         .with { if (!validate()) { errors.each { println it} } else save()} 
    551  
    552                         // fasting treatment template 
    553                         println ".adding fasting treatment template" 
    554                         def fastingTreatment = new Template( 
    555                                 name: 'Fasting treatment', 
    556                                 description: 'Fasting for a specific amount of time', 
    557                                 entity: dbnp.studycapturing.Event 
    558                         ) 
    559             .addToFields( 
    560                                 new TemplateField( 
    561                                         name: 'Fasting period', 
    562                                         type: TemplateFieldType.RELTIME, 
    563                                         entity: Event 
    564                                 ) 
    565                         ) 
    566                         .with { if (!validate()) { errors.each { println it} } else save()} 
    567  
    568                         // SamplingEvent templates 
    569                         println ".adding sampling protocol template field" 
    570             def samplingProtocolField = new TemplateField( 
    571                 name: 'Sample Protocol', 
    572                     entity: SamplingEvent, 
    573                                 type: TemplateFieldType.FILE, 
    574                                 comment: 'You can upload a protocol here which describes the procedure which was used when carrying out the sampling event' 
    575                         ) 
    576             .with { if (!validate()) { errors.each { println it} } else save()} 
    577  
    578                         // liver sampling event template 
    579                         println ".adding liver sampling event template" 
    580                         def liverSamplingEventTemplate = new Template( 
    581                                 name: 'Liver extraction', 
    582                                 description: 'Liver sampling for transcriptomics arrays', 
    583                                 entity: dbnp.studycapturing.SamplingEvent 
    584                         ) 
    585                         .addToFields(samplingProtocolField) 
    586                         .addToFields( 
    587                                 new TemplateField( 
    588                                         name: 'Sample weight', 
    589                                         unit: 'mg', 
    590                                         entity: SamplingEvent, 
    591                                         type: TemplateFieldType.FLOAT 
    592                                 ) 
    593                         ) 
    594                         .with { if (!validate()) { errors.each { println it} } else save()} 
    595  
    596                         // blood sampling 
    597                         println ".adding blood sampling event template" 
    598                         def bloodSamplingEventTemplate = new Template( 
    599                                 name: 'Blood extraction', 
    600                                 description: 'Blood extraction targeted at lipid assays', 
    601                         entity: dbnp.studycapturing.SamplingEvent 
    602                         ) 
    603             .addToFields(samplingProtocolField) 
    604                         .addToFields( 
    605                                 new TemplateField( 
    606                                         name: 'Sample volume', 
    607                                         entity: SamplingEvent, 
    608                                         unit: 'ml', 
    609                                         type: TemplateFieldType.FLOAT 
    610                                 ) 
    611                         ) 
    612                         .with { if (!validate()) { errors.each { println it} } else save()} 
    613  
    614                         // plant sample extraction event template 
    615                         println ".adding plant sample extraction event template" 
    616                         def plantSamplingExtractEventTemplate = new Template( 
    617                                 name: 'Plant sample extraction', 
    618                                 description: 'sample extraction', 
    619                                 entity: dbnp.studycapturing.SamplingEvent, 
    620                 sampleTemplates: [plantSampleTemplate] 
    621                         ) 
    622             .addToFields(samplingProtocolField) 
    623                         .addToFields( 
    624                                 new TemplateField( 
    625                                         name: 'Sample weight', 
    626                                         unit: 'ul', 
    627                                         entity: SamplingEvent, 
    628                                         type: TemplateFieldType.FLOAT 
    629                                 ) 
    630                         ) 
    631                         .addToFields( 
    632                                 new TemplateField( 
    633                                         name: 'Sample when measured', 
    634                                         type: TemplateFieldType.STRINGLIST, 
    635                                         entity: SamplingEvent, 
    636                         listEntries: [ 
    637                                                  new TemplateFieldListItem(name:'Dried'), 
    638                          new TemplateFieldListItem(name: 'Fresh'), 
    639                          new TemplateFieldListItem(name: 'Unknown') 
    640                                          ] 
    641                                 ) 
    642                         ) 
    643                         .with { if (!validate()) { errors.each { println it} } else save()} 
    644  
    645                         // plant sampling event template 
    646                         println ".adding plant sampling event template" 
    647             def plantSamplingEventTemplate = new Template( 
    648                                 name: 'Plant-sample ', 
    649                                 description: 'plant sample ', 
    650                                 entity: dbnp.studycapturing.SamplingEvent, 
    651                 sampleTemplates: [plantSampleTemplate] 
    652                         ) 
    653             //.addToFields(samplingProtocolField) 
    654                         .addToFields( 
    655                                 new TemplateField( 
    656                                         name: 'material', 
    657                         comment: 'physical charecteristic. e.g, grounded powder of tomato seed or liquid', 
    658                                         entity: SamplingEvent, 
    659                                         type: TemplateFieldType.STRING 
    660                                 ) 
    661                         ) 
    662             .addToFields( 
    663                                 new TemplateField( 
    664                                         name: 'Description', 
    665                                         type: TemplateFieldType.STRING, 
    666                                         entity: SamplingEvent 
    667                                 ) 
    668                         ) 
    669             .addToFields( 
    670                                 new TemplateField( 
    671                                         name: 'extracted material', 
    672                                         comment: 'substance to be extracted. e.g., lipids, volatiles, primary metabolites etc', 
    673                                         type: TemplateFieldType.STRING, 
    674                                         entity: SamplingEvent 
    675                                 ) 
    676                         ) 
    677             .addToFields( 
    678                                 new TemplateField( 
    679                                         name: 'Text on vial', 
    680                                         entity: SamplingEvent, 
    681                                         type: TemplateFieldType.STRING 
    682                                 ) 
    683                         ) 
    684                         .with { if (!validate()) { errors.each { println it} } else save()} 
     23                if (Template.count() == 0) { 
     24                        println "No templates in the current database."; 
     25                        // Add example study, subject, event etc. templates 
     26                        BootStrapTemplates.initTemplates() 
    68527 
    68628                        // Add example studies 
    687                         if (grails.util.GrailsUtil.environment == GrailsApplication.ENV_DEVELOPMENT) { 
     29                        if (Study.count() == 0 && grails.util.GrailsUtil.environment == GrailsApplication.ENV_DEVELOPMENT) { 
    68830 
    689                                 // Create a few persons, roles and Affiliations 
    690                                 println ".adding persons, roles and affiliations" 
    691                                 def affiliation1 = new PersonAffiliation( 
    692                                         institute: "Science Institute NYC", 
    693                                         department: "Department of Mathematics" 
    694                                 ).save(); 
    695                                 def affiliation2 = new PersonAffiliation( 
    696                                         institute: "InfoStats GmbH, Hamburg", 
    697                                         department: "Life Sciences" 
    698                                 ).save(); 
    699                                 def role1 = new PersonRole( 
    700                                         name: "Principal Investigator" 
    701                                 ).save(); 
    702                                 def role2 = new PersonRole( 
    703                                         name: "Statician" 
    704                                 ).save(); 
    705  
    706                                 // Create persons 
    707                                 def person1 = new Person( 
    708                                         lastName: "Scientist", 
    709                                         firstName: "John", 
    710                                         gender: "Male", 
    711                                         initials: "J.R.", 
    712                                         email: "john@scienceinstitute.com", 
    713                                         phone: "1-555-3049", 
    714                                         address: "First street 2,NYC" 
    715                                 ) 
    716                                 .addToAffiliations( affiliation1 ) 
    717                                 .addToAffiliations( affiliation2 ) 
    718                                 .save(); 
    719  
    720                                 def person2 = new Person( 
    721                                         lastName: "Statician", 
    722                                         firstName: "Jane", 
    723                                         gender: "Female", 
    724                                         initials: "W.J.", 
    725                                         email: "jane@statisticalcompany.de", 
    726                                         phone: "49-555-8291", 
    727                                         address: "Dritten strasse 38, Hamburg, Germany" 
    728                                 ) 
    729                                 .addToAffiliations( affiliation2 ) 
    730                                 .save(); 
    731  
    732                                 // Create 30 persons to test pagination 
    733                                 def personCounter = 1; 
    734                                 30.times { new Person( firstName: "Person #${personCounter}", lastName: "Testperson", email: "email${personCounter++}@testdomain.com" ).save() } 
    735  
    736                                 // Create a few publications 
    737                                 println ".adding publications" 
    738                                 def publication1 = new Publication( 
    739                                         title: "Postnatal development of hypothalamic leptin receptors", 
    740                                         authorsList: "Cottrell EC, Mercer JG, Ozanne SE.", 
    741                                         pubMedID: "20472140", 
    742                                         comments: "Not published yet", 
    743                                         DOI: "unknown" 
    744                                 ) 
    745                                 .save(); 
    746  
    747                                 def publication2 = new Publication( 
    748                                         title: "Induction of regulatory T cells decreases adipose inflammation and alleviates insulin resistance in ob/ob mice", 
    749                                         authorsList: "Ilan Y, Maron R, Tukpah AM, Maioli TU, Murugaiyan G, Yang K, Wu HY, Weiner HL.", 
    750                                         pubMedID: "20445103", 
    751                                         comments: "", 
    752                                         DOI: "" 
    753                                 ) 
    754                                 .save(); 
    755  
    756                                 // Add example mouse study 
    757                                 println ".adding NuGO PPS3 leptin example study..." 
    758                                 def mouseStudy = new Study( 
    759                                         template: studyTemplate, 
    760                                         title:"NuGO PPS3 mouse study leptin module", 
    761                                         code:"PPS3_leptin_module", 
    762                                         researchQuestion:"Leptin etc.", 
    763                                         ecCode:"2007117.c", 
    764                                         startDate: Date.parse('yyyy-MM-dd','2008-01-02'), 
    765                                 ) 
    766                                 .with { if (!validate()) { errors.each { println it} } else save()} 
    767  
    768                                 mouseStudy.setFieldValue('Description', "C57Bl/6 mice were fed a high fat (45 en%) or low fat (10 en%) diet after a four week run-in on low fat diet.");// After 1 week 10 mice that received a low fat diet were given an IP leptin challenge and 10 mice of the low-fat group received placebo injections. The same procedure was performed with mice that were fed the high-fat diet. After 4 weeks the procedure was repeated. In total 80 mice were culled." ) 
    769                                 mouseStudy.save() 
    770  
    771                                 def evLF = new Event( 
    772                                         startTime: 3600, 
    773                                         endTime: 3600 +7 * 24 * 3600, 
    774                                         template: dietTreatmentTemplate 
    775                                 ) 
    776                                 .setFieldValue( 'Diet','low fat') 
    777                                 .with { if (!validate()) { errors.each { println it} } else save()} 
    778  
    779                                 def evHF = new Event( 
    780                                         startTime: 3600, 
    781                                         endTime: 3600 +7 * 24 * 3600, 
    782                                         template: dietTreatmentTemplate 
    783                                 ) 
    784                                 .setFieldValue( 'Diet','high fat' ) 
    785                                 .with { if (!validate()) { errors.each { println it} } else save()} 
    786  
    787                                 def evBV = new Event( 
    788                                         startTime: 3600, 
    789                                         endTime: 3600 +7 * 24 * 3600, 
    790                                         template: boostTreatmentTemplate 
    791                                 ) 
    792                                 .setFieldValue( 'Control','true' ) 
    793                                 .with { if (!validate()) { errors.each { println it} } else save()} 
    794  
    795                                 def evBL = new Event( 
    796                                         startTime: 3600, 
    797                                         endTime: 3600 +7 * 24 * 3600, 
    798                                         template: boostTreatmentTemplate 
    799                                 ) 
    800                                 .setFieldValue( 'Control','false' ) 
    801                                 .with { if (!validate()) { errors.each { println it} } else save()} 
    802  
    803                                 def evLF4 = new Event( 
    804                                         startTime: 3600, 
    805                                         endTime: 3600 + 4 * 7 * 24 * 3600, 
    806                                         template: dietTreatmentTemplate 
    807                                 ) 
    808                                 .setFieldValue( 'Diet','low fat') 
    809                                 .with { if (!validate()) { errors.each { println it} } else save()} 
    810  
    811                                 def evHF4 = new Event( 
    812                                         startTime: 3600, 
    813                                         endTime: 3600 + 4 * 7 * 24 * 3600, 
    814                                         template: dietTreatmentTemplate 
    815                                 ) 
    816                                 .setFieldValue( 'Diet','high fat' ) 
    817                                 .with { if (!validate()) { errors.each { println it} } else save()} 
    818  
    819                                 def evBV4 = new Event( 
    820                                         startTime: 3600, 
    821                                         endTime: 3600 + 4 * 7 * 24 * 3600, 
    822                                         template: boostTreatmentTemplate 
    823                                 ) 
    824                                 .setFieldValue( 'Control','true' ) 
    825                                 .with { if (!validate()) { errors.each { println it} } else save()} 
    826  
    827                                 def evBL4 = new Event( 
    828                                         startTime: 3600, 
    829                                         endTime: 3600 + 4 * 7 * 24 * 3600, 
    830                                         template: boostTreatmentTemplate 
    831                                 ) 
    832                                 .setFieldValue( 'Control','false' ) 
    833                                 .with { if (!validate()) { errors.each { println it} } else save()} 
    834  
    835                                 def evS = new SamplingEvent( 
    836                                         startTime: 3600 +7 * 24 * 3600, 
    837                                         endTime: 3600 +7 * 24 * 3600, 
    838                                         template: liverSamplingEventTemplate) 
    839                                 .setFieldValue('Sample weight',5F) 
    840                                 .with { if (!validate()) { errors.each { println it} } else save()} 
    841  
    842                                 def evS4 = new SamplingEvent( 
    843                                         startTime: 3600 +7 * 24 * 3600, 
    844                                         endTime: 3600 +7 * 24 * 3600, 
    845                                         template: liverSamplingEventTemplate) 
    846                                 .setFieldValue('Sample weight',5F) 
    847                                 .with { if (!validate()) { errors.each { println it} } else save()} 
    848  
    849                                 // Add events to study 
    850                                 mouseStudy 
    851                                 .addToEvents(evLF) 
    852                                 .addToEvents(evHF) 
    853                                 .addToEvents(evBV) 
    854                                 .addToEvents(evBL) 
    855                                 .addToEvents(evLF4) 
    856                                 .addToEvents(evHF4) 
    857                                 .addToEvents(evBV4) 
    858                                 .addToEvents(evBL4) 
    859                                 .addToSamplingEvents(evS) 
    860                                 .addToSamplingEvents(evS4) 
    861                                 .save() 
    862  
    863                                 def LFBV1 = new EventGroup(name:"10% fat + vehicle for 1 week") 
    864                                 .addToEvents(evLF) 
    865                                 .addToEvents(evBV) 
    866                                 .addToEvents(evS) 
    867                                 .with { if (!validate()) { errors.each { println it} } else save()} 
    868  
    869                                 def LFBL1 = new EventGroup(name:"10% fat + leptin for 1 week") 
    870                                 .addToEvents(evLF) 
    871                                 .addToEvents(evBL) 
    872                                 .addToEvents(evS) 
    873                                 .with { if (!validate()) { errors.each { println it} } else save()} 
    874  
    875                                 def HFBV1 = new EventGroup(name:"45% fat + vehicle for 1 week") 
    876                                 .addToEvents(evHF) 
    877                                 .addToEvents(evBV) 
    878                                 .addToEvents(evS) 
    879                                 .with { if (!validate()) { errors.each { println it} } else save()} 
    880  
    881                                 def HFBL1 = new EventGroup(name:"45% fat + leptin for 1 week") 
    882                                 .addToEvents(evHF) 
    883                                 .addToEvents(evBL) 
    884                                 .addToEvents(evS) 
    885                                 .with { if (!validate()) { errors.each { println it} } else save()} 
    886  
    887                                 def LFBV4 = new EventGroup(name:"10% fat + vehicle for 4 weeks") 
    888                                 .addToEvents(evLF4) 
    889                                 .addToEvents(evBV4) 
    890                                 .addToEvents(evS4) 
    891                                 .with { if (!validate()) { errors.each { println it} } else save()} 
    892  
    893                                 def LFBL4 = new EventGroup(name:"10% fat + leptin for 4 weeks") 
    894                                 .addToEvents(evLF4) 
    895                                 .addToEvents(evBL4) 
    896                                 .addToEvents(evS4) 
    897                                 .with { if (!validate()) { errors.each { println it} } else save()} 
    898  
    899                                 def HFBV4 = new EventGroup(name:"45% fat + vehicle for 4 weeks") 
    900                                 .addToEvents(evHF4) 
    901                                 .addToEvents(evBV4) 
    902                                 .addToEvents(evS4) 
    903                                 .with { if (!validate()) { errors.each { println it} } else save()} 
    904  
    905                                 def HFBL4 = new EventGroup(name:"45% fat + leptin for 4 weeks") 
    906                                 .addToEvents(evHF4) 
    907                                 .addToEvents(evBL4) 
    908                                 .addToEvents(evS4) 
    909                                 .with { if (!validate()) { errors.each { println it} } else save()} 
    910  
    911                 // Add subjects and samples and compose EventGroups 
    912                                 def x=1 
    913                                 20.times { 
    914                                         def currentSubject = new Subject( 
    915                                                 name: "A" + x++, 
    916                                                 species: mouseTerm, 
    917                                                 template: mouseTemplate, 
    918                                         ) 
    919                                         .setFieldValue("Gender", "Male") 
    920                                         .setFieldValue("Genotype", c57bl6Term) 
    921                                         .setFieldValue("Age", 17) 
    922                                         .setFieldValue("Cage", "" + (int)(x/2)) 
    923                                         .with { if (!validate()) { errors.each { println it} } else save(flush:true)} 
    924  
    925                                         mouseStudy.addToSubjects(currentSubject) 
    926                                         .with { if (!validate()) { errors.each { println it} } else save()} 
    927  
    928                                         // Add subject to appropriate EventGroup 
    929                                         if (x > 70) { HFBL4.addToSubjects(currentSubject).save() } 
    930                                         else if (x > 60) { HFBV4.addToSubjects(currentSubject).save() } 
    931                                         else if (x > 50) { LFBL4.addToSubjects(currentSubject).save() } 
    932                                         else if (x > 40) { LFBV4.addToSubjects(currentSubject).save() } 
    933                                         else if (x > 30) { HFBL1.addToSubjects(currentSubject).save() } 
    934                                         else if (x > 20) { HFBV1.addToSubjects(currentSubject).save() } 
    935                                         else if (x > 10) { LFBL1.addToSubjects(currentSubject).save() } 
    936                                         else             { LFBV1.addToSubjects(currentSubject).save() } 
    937  
    938                                 } 
    939  
    940                                 // Add EventGroups to study 
    941                                 mouseStudy 
    942                                 .addToEventGroups(LFBV1) 
    943                                 .addToEventGroups(LFBL1) 
    944                                 .addToEventGroups(HFBV1) 
    945                                 .addToEventGroups(HFBL1) 
    946                                 .addToEventGroups(LFBV4) 
    947                                 .addToEventGroups(LFBL4) 
    948                                 .addToEventGroups(HFBV4) 
    949                                 .addToEventGroups(HFBL4) 
    950  
    951                                 // Add persons and publications to study 
    952                                 def studyperson1 = new StudyPerson( person: person1, role: role1 ).save(); 
    953                                 def studyperson2 = new StudyPerson( person: person2, role: role2 ).save(); 
    954  
    955                                 mouseStudy 
    956                                 .addToPersons( studyperson1 ) 
    957                                 .addToPersons( studyperson2 ) 
    958                 .addToPublications( publication1 ) 
    959                 .addToPublications( publication2 ) 
    960                                 .save() 
    961  
    962                                 // Add example human study 
    963                                 println ".adding NuGO PPSH example study..." 
    964  
    965                                 def humanStudy = new Study( 
    966                                         template: studyTemplate, 
    967                                         title:"NuGO PPS human study", 
    968                                         code:"PPSH", 
    969                                         researchQuestion:"How much are fasting plasma and urine metabolite levels affected by prolonged fasting ?", 
    970                                         description:"Human study", 
    971                                         ecCode:"unknown", 
    972                                         startDate: Date.parse('yyyy-MM-dd','2008-01-14'), 
    973                                 ) 
    974                                 .setFieldValue( 'Description', "Human study performed at RRI; centres involved: RRI, IFR, TUM, Maastricht U." ) 
    975                                 .with { if (!validate()) { errors.each { println it} } else save()} 
    976  
    977                                 def rootGroup = new EventGroup(name: 'Root group'); 
    978  
    979                                 def fastingEvent = new Event( 
    980                                         startTime: 3 * 24 * 3600 + 22 * 3600, 
    981                                         endTime: 3 * 24 * 3600 + 30 * 3600, 
    982                                         template: fastingTreatment) 
    983                                 .setFieldValue('Fasting period','8h'); 
    984  
    985  
    986                                 def bloodSamplingEvent = new SamplingEvent( 
    987                                         startTime: 3 * 24 * 3600 + 30 * 3600, 
    988                                         endTime: 3 * 24 * 3600 + 30 * 3600, 
    989                                         template: bloodSamplingEventTemplate) 
    990                                 .setFieldValue('Sample volume',4.5F); 
    991  
    992                                 rootGroup.addToEvents fastingEvent 
    993                                 rootGroup.addToEvents bloodSamplingEvent 
    994                                 rootGroup.save() 
    995  
    996                                 def y = 1 
    997                                 11.times { 
    998                                         def currentSubject = new Subject( 
    999                                                 name: "" + y++, 
    1000                                                 species: humanTerm, 
    1001                                                 template: humanTemplate 
    1002                                         ) 
    1003                                         .setFieldValue("Gender", (Math.random() > 0.5) ? "Male" : "Female") 
    1004                                         .setFieldValue("DOB", new java.text.SimpleDateFormat("dd-mm-yy").parse("01-02-19" + (10 + (int) (Math.random() * 80)))) 
    1005                                         .setFieldValue("Age", 30) 
    1006                                         .setFieldValue("Height", Math.random() * 2F) 
    1007                                         .setFieldValue("Weight", Math.random() * 150F) 
    1008                                         .setFieldValue("BMI", 20 + Math.random() * 10F) 
    1009                                         .with { if (!validate()) { errors.each { println it} } else save()} 
    1010  
    1011                                         rootGroup.addToSubjects currentSubject 
    1012                                         rootGroup.save() 
    1013  
    1014                                         def currentSample = new Sample( 
    1015                                                 name: currentSubject.name + '_B', 
    1016                                                 material: bloodTerm, 
    1017                                                 template: humanBloodSampleTemplate, 
    1018                                                 parentSubject: currentSubject, 
    1019                                                 parentEvent: bloodSamplingEvent 
    1020                                         ); 
    1021                                         currentSample.setFieldValue( "Text on vial", "T" + (Math.random() * 100L) ) 
    1022  
    1023                                         humanStudy.addToSubjects(currentSubject).addToSamples(currentSample).with { if (!validate()) { errors.each { println it} } else save()} 
    1024                                 } 
    1025  
    1026                                 humanStudy.addToEvents(fastingEvent) 
    1027                                 humanStudy.addToSamplingEvents(bloodSamplingEvent) 
    1028                                 humanStudy.addToEventGroups rootGroup 
    1029  
    1030  
    1031                                 // Add persons to study 
    1032                                 def studyperson3 = new StudyPerson( person: person1, role: role2 ).save(); 
    1033  
    1034                                 humanStudy 
    1035                                 .addToPersons( studyperson3 ) 
    1036                                 .addToPublications( publication2 ) 
    1037                                 .save() 
    1038  
    1039                                 /* 
    1040                                 // Add clinical data 
    1041  
    1042                                 def lipidAssay = new dbnp.clinicaldata.ClinicalAssay( 
    1043                                         name: 'Lipid profile', 
    1044                                         approved: true 
    1045                                 ).with { if (!validate()) { errors.each { println it} } else save()} 
    1046  
    1047                                 def ldlMeasurement = new dbnp.clinicaldata.ClinicalMeasurement( 
    1048                                         name: 'LDL', 
    1049                                         unit: 'mg/dL', 
    1050                                         type: dbnp.data.FeatureType.QUANTITATIVE, 
    1051                                         referenceValues: '100 mg/dL', 
    1052                                         detectableLimit: 250, 
    1053                                         isDrug: false, isIntake: true, inSerum: true 
    1054                                 ).with { if (!validate()) { errors.each { println it} } else save()} 
    1055  
    1056                                 def hdlMeasurement = new dbnp.clinicaldata.ClinicalMeasurement( 
    1057                                         name: 'HDL', 
    1058                                         unit: 'mg/dL', 
    1059                                         type: dbnp.data.FeatureType.QUANTITATIVE, 
    1060                                         referenceValues: '50 mg/dL', 
    1061                                         detectableLimit: 100, 
    1062                                         isDrug: false, isIntake: true, inSerum: true 
    1063                                 ).with { if (!validate()) { errors.each { println it} } else save()} 
    1064  
    1065                                 lipidAssay.addToMeasurements ldlMeasurement 
    1066                                 lipidAssay.addToMeasurements hdlMeasurement 
    1067  
    1068                                 def lipidAssayInstance = new dbnp.clinicaldata.ClinicalAssayInstance( 
    1069                                         assay: lipidAssay 
    1070                                 ).with { if (!validate()) { errors.each { println it} } else save()} 
    1071  
    1072                                 humanStudy.samples*.each { 
    1073                                         new dbnp.clinicaldata.ClinicalFloatData( 
    1074                                                 assay: lipidAssayInstance, 
    1075                                                 measurement: ldlMeasurement, 
    1076                                                 sample: it.name, 
    1077                                                 value: Math.round(Math.random()*ldlMeasurement.detectableLimit) 
    1078                                         ).with { if (!validate()) { errors.each { println it} } else save()} 
    1079  
    1080                                         new dbnp.clinicaldata.ClinicalFloatData( 
    1081                                                 assay: lipidAssayInstance, 
    1082                                                 measurement: hdlMeasurement, 
    1083                                                 sample: it.name, 
    1084                                                 value: Math.round(Math.random()*hdlMeasurement.detectableLimit) 
    1085                                         ).with { if (!validate()) { errors.each { println it} } else save()} 
    1086                                 } 
    1087                                 */ 
    1088                                 // Add assay to study capture module 
    1089  
    1090                                 def clinicalModule = new AssayModule( 
    1091                                         name: 'Clinical data', 
    1092                                         type: AssayType.CLINICAL_DATA, 
    1093                                         platform: 'clinical measurements', 
    1094                                         url: 'http://localhost:8080/gscf' 
    1095                                 ).with { if (!validate()) { errors.each { println it} } else save()} 
    1096  
    1097                                 def lipidAssayRef = new Assay( 
    1098                                         name: 'Lipid profiling', 
    1099                                         module: clinicalModule, 
    1100                                         externalAssayId: 0 
    1101                                 ).with { if (!validate()) { errors.each { println it} } else save()} 
    1102  
    1103                                 humanStudy.samples*.each { 
    1104                                         lipidAssayRef.addToSamples(it) 
    1105                                 } 
    1106                                 lipidAssayRef.save() 
    1107  
    1108                                 humanStudy.addToAssays(lipidAssayRef); 
    1109                                 humanStudy.save() 
    1110  
    1111                         mouseStudy.addToAssays(lipidAssayRef); 
    1112                                 mouseStudy.save() 
    1113  
     31                                // When the code is properly refactored, BootStrapStudies.addExampleStudies() may be called here 
    111432                        } 
    111533                }