Changeset 364

Show
Ignore:
Timestamp:
21-04-10 12:02:29 (4 years ago)
Author:
keesvb
Message:

getting studies back in bootstrap

Files:
1 modified

Legend:

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

    r360 r364  
    1 import org.codehaus.groovy.grails.commons.GrailsApplication 
    2 import grails.util.GrailsUtil 
    31import dbnp.studycapturing.* 
    42 
    53import dbnp.data.Ontology 
    64import dbnp.data.Term 
    7 import java.text.SimpleDateFormat 
    85 
    96/** 
     
    2623                        println ".development bootstrapping..."; 
    2724 
    28                         // adding the academic 
     25                        // add NCBI species ontology 
     26                        println ".adding NCBI species ontology" 
     27                        def speciesOntology = new Ontology( 
     28                                name: 'NCBI organismal classification', 
     29                                description: 'A taxonomic classification of living organisms and associated artifacts for their controlled description within the context of databases.', 
     30                                url: 'http://www.ncbi.nlm.nih.gov/Taxonomy/taxonomyhome.html/', 
     31                                versionNumber: '1.2', 
     32                                ncboId: '1132', 
     33                                ncboVersionedId: '38802' 
     34                        ).with { if (!validate()) { errors.each { println it} } else save()} 
     35 
     36                        // add TERMS 
     37                        println ".adding mouse term" 
     38                        def mouseTerm = new Term( 
     39                                name: 'Mus musculus', 
     40                                ontology: speciesOntology, 
     41                                accession: '10090' 
     42                        ).with { if (!validate()) { errors.each { println it} } else save()} 
     43                        println ".adding human term" 
     44                        def humanTerm = new Term( 
     45                                name: 'Homo sapiens', 
     46                                ontology: speciesOntology, 
     47                                accession: '9606' 
     48                        ).with { if (!validate()) { errors.each { println it} } else save()} 
     49 
     50 
     51 /*   COMMENTED OUT BECAUSE IT BREAKS EVERYTHING AFTER REFACTORING THE DATAMODEL 
     52 
     53                        // ontologies 
     54                        def speciesOntology = new Ontology( 
     55                                name: 'NCBI Taxonomy', 
     56                                shortName: 'Taxon', 
     57                                url: 'http://www.obofoundry.org/cgi-bin/detail.cgi?id=ncbi_taxonomy' 
     58                        ).with { if (!validate()) { errors.each { println it} } else save()} 
     59 
     60                        def humanBodyOntology = new Ontology( 
     61                                name: 'Foundational Model of Anatomy', 
     62                                shortName: 'HumanBody', 
     63                                url: 'http://bioportal.bioontology.org/ontologies/39966' 
     64                        ).with { if (!validate()) { errors.each { println it} } else save()} 
     65 
     66                        def nciOntology = new Ontology( 
     67                                name: 'NCI Thesaurus', 
     68                                shortName: 'NCI', 
     69                                url: 'http://bioportal.bioontology.org/ontologies/42331' 
     70                        ).with { if (!validate()) { errors.each { println it} } else save()} 
     71 
     72                        // terms 
     73                        def mouseTerm = new Term( 
     74                                name: 'Mus musculus', 
     75                                ontology: speciesOntology, 
     76                                accession: '10090' 
     77                        ).with { if (!validate()) { errors.each { println it} } else save()} 
     78                        def humanTerm = new Term( 
     79                                name: 'Homo sapiens', 
     80                                ontology: speciesOntology, 
     81                                accession: '9606' 
     82                        ).with { if (!validate()) { errors.each { println it} } else save()} 
     83                        def arabTerm = new Term( 
     84                                name: 'Arabidopsis thaliana', 
     85                                ontology: speciesOntology, 
     86                                accession: '3702' 
     87                        ).with { if (!validate()) { errors.each { println it} } else save()} 
     88                         
     89                        def bloodTerm = new Term( 
     90                                name: 'Portion of blood', 
     91                                ontology: humanBodyOntology, 
     92                                accession: '9670' 
     93                        ).with { if (!validate()) { errors.each { println it} } else save()} 
     94 
     95                        def c57bl6Term = new Term( 
     96                                name: 'C57BL/6 Mouse', 
     97                                ontology: nciOntology, 
     98                                accession: 'C14424' 
     99                        ).with { if (!validate()) { errors.each { println it} } else save()} 
     100 
     101                        def madmaxOntology = new Ontology( 
     102                                name: 'Madmax ontology', 
     103                                shortName: 'MDMX', 
     104                                url: 'madmax.bioinformatics.nl' 
     105                        ).with { if (!validate()) { errors.each { println it} } else save()} 
     106 
     107                        def treatmentTerm = new Term( 
     108                                name: 'ExperimentalProtocol', 
     109                                ontology: madmaxOntology, 
     110                                accession: 'P-MDMXGE-264' 
     111                        ).with { if (!validate()) { errors.each { println it} } else save()} 
     112 
     113                        def dietProtocol = new Protocol( 
     114                                name: 'Diet treatment Protocol NuGO PPS3 leptin module', 
     115                                reference: treatmentTerm 
     116                        ).with { if (!validate()) { errors.each { println it} } else save()} 
     117 
     118                        def boostProtocol = new Protocol( 
     119                                name: 'Boost treatment Protocol NuGO PPS3 leptin module', 
     120                                reference: treatmentTerm 
     121                        ).with { if (!validate()) { errors.each { println it} } else save()} 
     122 
     123                        def fastingProtocol = new Protocol( 
     124                                name: 'Fasting', 
     125                                reference: treatmentTerm 
     126                        ).with { if (!validate()) { errors.each { println it} } else save()} 
     127 
     128 
     129                        // ParameterStringListItems 
     130                        def oil10= new ParameterStringListItem( 
     131                                name: '10% fat (palm oil)' 
     132                        ).with { if (!validate()) { errors.each { println it} } else save()} 
     133                        def oil45= new ParameterStringListItem( 
     134                                name: '45% fat (palm oil)' 
     135                        ).with { if (!validate()) { errors.each { println it} } else save()} 
     136                        def vehicle= new ParameterStringListItem( 
     137                                name: 'Vehicle' 
     138                        ).with { if (!validate()) { errors.each { println it} } else save()} 
     139                        def leptin= new ParameterStringListItem( 
     140                                name: 'Leptin' 
     141                        ).with { if (!validate()) { errors.each { println it} } else save()} 
     142 
     143 
     144                        dietProtocol 
     145                        .addToParameters(new ProtocolParameter( 
     146                                name: 'Diet', 
     147                                type: ProtocolParameterType.STRINGLIST, 
     148                                listEntries: [oil10,oil45])) 
     149                        .save() 
     150 
     151                        boostProtocol 
     152                        .addToParameters(new ProtocolParameter( 
     153                                name: 'Compound', 
     154                                type: ProtocolParameterType.STRINGLIST, 
     155                                listEntries: [vehicle,leptin])) 
     156                        .save() 
     157 
     158                        fastingProtocol 
     159                        .addToParameters(new ProtocolParameter( 
     160                                name: 'Fasting period', 
     161                                type: ProtocolParameterType.STRING)) 
     162                        .save() 
     163 
     164 
     165                        // sampling event protocols 
     166 
     167                        def liverSamplingProtocol = new Protocol( 
     168                                name: 'Liver sampling' 
     169                        ).with { if (!validate()) { errors.each { println it} } else save()} 
     170 
     171                        liverSamplingProtocol 
     172                        .addToParameters(new ProtocolParameter( 
     173                                name: 'Sample weight', 
     174                                unit: 'mg', 
     175                                type: ProtocolParameterType.FLOAT)) 
     176                        .save() 
     177 
     178                        def bloodSamplingProtocol = new Protocol( 
     179                                name: 'Blood sampling' 
     180                        ).with { if (!validate()) { errors.each { println it} } else save()} 
     181 
     182                        bloodSamplingProtocol 
     183                        .addToParameters(new ProtocolParameter( 
     184                                name: 'Sample volume', 
     185                                unit: 'ml', 
     186                                type: ProtocolParameterType.FLOAT)) 
     187                        .save() 
     188 */ 
     189                        // create system user 
     190 
     191                        /*def systemUser = userService.createUser(InstanceGenerator.user( 
     192                                username: 'system', 
     193                                pass: 'system', 
     194                                passConfirm: 'system', 
     195                                enabled: true 
     196                        ))*/ 
     197 
     198  
     199                        def genderField = new TemplateField( 
     200                                name: 'Gender',type: TemplateFieldType.STRINGLIST, 
     201                                listEntries: [new TemplateFieldListItem(name:'Male'),new TemplateFieldListItem(name: 'Female')]) 
     202                        .with { if (!validate()) { errors.each { println it} } else save()} 
     203 
     204                        def ageField = new TemplateField( 
     205                                name: 'Age (years)',type: TemplateFieldType.INTEGER,unit: 'years') 
     206                        .with { if (!validate()) { errors.each { println it} } else save()} 
     207 
     208                        def genotypeField = new TemplateField( 
     209                                name: 'Genotype', type: TemplateFieldType.ONTOLOGYTERM) 
     210                        .with { if (!validate()) { errors.each { println it} } else save()} 
     211 
     212                        def genotypeTypeField = new TemplateField( 
     213                                name: 'Genotype type',type: TemplateFieldType.STRINGLIST, 
     214                                listEntries: [new TemplateFieldListItem(name:'transgenic'), 
     215                                        new TemplateFieldListItem(name:'knock-out'), 
     216                                        new TemplateFieldListItem(name:'knock-in')]) 
     217                        .with { if (!validate()) { errors.each { println it} } else save()} 
     218 
     219 
     220                        // Nutritional study template 
     221 
    29222                        println ".adding academic study template..." 
    30223                        def studyTemplate = new Template( 
     
    38231                        .with { if (!validate()) { errors.each { println it} } else save()} 
    39232 
    40                         // Mouse template 
     233                        // Mouse template 
    41234                        println ".adding mouse subject template..." 
    42                         def mouseTemplate = new Template( 
    43                                 name: 'Mouse', entity: dbnp.studycapturing.Subject) 
    44                         .addToFields(new TemplateField( 
    45                                 name: 'Strain', type: TemplateFieldType.ONTOLOGYTERM)) 
    46                         //.addToFields(genotypeField) 
    47                         //.addToFields(genotypeTypeField) 
    48                         //.addToFields(genderField) 
    49                         .addToFields(new TemplateField( 
    50                                 name: 'Age (weeks)', type: TemplateFieldType.INTEGER, unit: 'weeks')) 
    51                         .addToFields(new TemplateField( 
    52                                 name: 'Age type',type: TemplateFieldType.STRINGLIST, 
    53                                 listEntries: [new TemplateFieldListItem(name:'postnatal'),new TemplateFieldListItem(name:'embryonal')])) 
    54                         .addToFields(new TemplateField( 
    55                                 name: 'Cage',type: TemplateFieldType.STRING)) 
    56                         .addToFields(new TemplateField( 
    57                                 name: '#Mice in cage',type: TemplateFieldType.INTEGER)) 
    58                         .addToFields(new TemplateField( 
    59                                 name: 'Litter size',type: TemplateFieldType.INTEGER)) 
    60                         .addToFields(new TemplateField( 
    61                                 name: 'Weight (g)', type: TemplateFieldType.DOUBLE, unit: 'gram')) 
    62                         .with { if (!validate()) { errors.each { println it} } else save()} 
    63  
    64                         // Human template 
    65                         println ".adding human subject template..." 
    66                         def humanTemplate = new Template( 
    67                                 name: 'Human', entity: dbnp.studycapturing.Subject) 
    68                         //.addToFields(genderField) 
    69                         //.addToFields(ageField) 
    70                         .addToFields(new TemplateField( 
    71                                 name: 'DOB',type: TemplateFieldType.DATE)) 
    72                         .addToFields(new TemplateField( 
    73                                 name: 'Height',type: TemplateFieldType.DOUBLE, unit: 'm')) 
    74                         .addToFields(new TemplateField( 
    75                                 name: 'Weight (kg)',type: TemplateFieldType.DOUBLE, unit: 'kg')) 
    76                         .addToFields(new TemplateField( 
    77                                 name: 'BMI',type: TemplateFieldType.DOUBLE, unit: 'kg/m2')) 
    78                         .addToFields(new TemplateField( 
    79                                 name: 'Race',type: TemplateFieldType.STRING)) 
    80                         .addToFields(new TemplateField( 
    81                                 name: 'Waist circumference',type: TemplateFieldType.FLOAT, unit: 'cm')) 
    82                         .addToFields(new TemplateField( 
    83                                 name: 'Hip circumference',type: TemplateFieldType.FLOAT, unit: 'cm')) 
    84                         .addToFields(new TemplateField( 
    85                                 name: 'Systolic blood pressure',type: TemplateFieldType.FLOAT, unit: 'mmHg')) 
    86                         .addToFields(new TemplateField( 
    87                                 name: 'Diastolic blood pressure',type: TemplateFieldType.FLOAT, unit: 'mmHg')) 
    88                         .addToFields(new TemplateField( 
    89                                 name: 'Heart rate',type: TemplateFieldType.FLOAT, unit: 'beats/min')) 
    90                         .addToFields(new TemplateField( 
    91                                 name: 'Run-in-food',type: TemplateFieldType.TEXT)) 
    92                         .with { if (!validate()) { errors.each { println it} } else save()} 
    93  
    94                         // add NCBI species ontology 
    95                         println ".adding NCBI species ontology" 
    96                         def speciesOntology = new Ontology( 
    97                                 name: 'NCBI organismal classification', 
    98                                 description: 'A taxonomic classification of living organisms and associated artifacts for their controlled description within the context of databases.', 
    99                                 url: 'http://www.ncbi.nlm.nih.gov/Taxonomy/taxonomyhome.html/', 
    100                                 versionNumber: '1.2', 
    101                                 ncboId: '1132', 
    102                                 ncboVersionedId: '38802' 
    103                         ).with { if (!validate()) { errors.each { println it} } else save()} 
    104  
    105                         // add TERMS 
    106                         println ".adding mouse term" 
    107                         def mouseTerm = new Term( 
    108                                 name: 'Mus musculus', 
    109                                 ontology: speciesOntology, 
    110                                 accession: '10090' 
    111                         ).with { if (!validate()) { errors.each { println it} } else save()} 
    112                         println ".adding human term" 
    113                         def humanTerm = new Term( 
    114                                 name: 'Homo sapiens', 
    115                                 ontology: speciesOntology, 
    116                                 accession: '9606' 
    117                         ).with { if (!validate()) { errors.each { println it} } else save()} 
    118  
    119  
    120  /*   COMMENTED OUT BECAUSE IT BREAKS EVERYTHING AFTER REFACTORING THE DATAMODEL 
    121  
    122                         // ontologies 
    123                         def speciesOntology = new Ontology( 
    124                                 name: 'NCBI Taxonomy', 
    125                                 shortName: 'Taxon', 
    126                                 url: 'http://www.obofoundry.org/cgi-bin/detail.cgi?id=ncbi_taxonomy' 
    127                         ).with { if (!validate()) { errors.each { println it} } else save()} 
    128  
    129                         def humanBodyOntology = new Ontology( 
    130                                 name: 'Foundational Model of Anatomy', 
    131                                 shortName: 'HumanBody', 
    132                                 url: 'http://bioportal.bioontology.org/ontologies/39966' 
    133                         ).with { if (!validate()) { errors.each { println it} } else save()} 
    134  
    135                         def nciOntology = new Ontology( 
    136                                 name: 'NCI Thesaurus', 
    137                                 shortName: 'NCI', 
    138                                 url: 'http://bioportal.bioontology.org/ontologies/42331' 
    139                         ).with { if (!validate()) { errors.each { println it} } else save()} 
    140  
    141                         // terms 
    142                         def mouseTerm = new Term( 
    143                                 name: 'Mus musculus', 
    144                                 ontology: speciesOntology, 
    145                                 accession: '10090' 
    146                         ).with { if (!validate()) { errors.each { println it} } else save()} 
    147                         def humanTerm = new Term( 
    148                                 name: 'Homo sapiens', 
    149                                 ontology: speciesOntology, 
    150                                 accession: '9606' 
    151                         ).with { if (!validate()) { errors.each { println it} } else save()} 
    152                         def arabTerm = new Term( 
    153                                 name: 'Arabidopsis thaliana', 
    154                                 ontology: speciesOntology, 
    155                                 accession: '3702' 
    156                         ).with { if (!validate()) { errors.each { println it} } else save()} 
    157                          
    158                         def bloodTerm = new Term( 
    159                                 name: 'Portion of blood', 
    160                                 ontology: humanBodyOntology, 
    161                                 accession: '9670' 
    162                         ).with { if (!validate()) { errors.each { println it} } else save()} 
    163  
    164                         def c57bl6Term = new Term( 
    165                                 name: 'C57BL/6 Mouse', 
    166                                 ontology: nciOntology, 
    167                                 accession: 'C14424' 
    168                         ).with { if (!validate()) { errors.each { println it} } else save()} 
    169  
    170                         def madmaxOntology = new Ontology( 
    171                                 name: 'Madmax ontology', 
    172                                 shortName: 'MDMX', 
    173                                 url: 'madmax.bioinformatics.nl' 
    174                         ).with { if (!validate()) { errors.each { println it} } else save()} 
    175  
    176                         def treatmentTerm = new Term( 
    177                                 name: 'ExperimentalProtocol', 
    178                                 ontology: madmaxOntology, 
    179                                 accession: 'P-MDMXGE-264' 
    180                         ).with { if (!validate()) { errors.each { println it} } else save()} 
    181  
    182                         def dietProtocol = new Protocol( 
    183                                 name: 'Diet treatment Protocol NuGO PPS3 leptin module', 
    184                                 reference: treatmentTerm 
    185                         ).with { if (!validate()) { errors.each { println it} } else save()} 
    186  
    187                         def boostProtocol = new Protocol( 
    188                                 name: 'Boost treatment Protocol NuGO PPS3 leptin module', 
    189                                 reference: treatmentTerm 
    190                         ).with { if (!validate()) { errors.each { println it} } else save()} 
    191  
    192                         def fastingProtocol = new Protocol( 
    193                                 name: 'Fasting', 
    194                                 reference: treatmentTerm 
    195                         ).with { if (!validate()) { errors.each { println it} } else save()} 
    196  
    197  
    198                         // ParameterStringListItems 
    199                         def oil10= new ParameterStringListItem( 
    200                                 name: '10% fat (palm oil)' 
    201                         ).with { if (!validate()) { errors.each { println it} } else save()} 
    202                         def oil45= new ParameterStringListItem( 
    203                                 name: '45% fat (palm oil)' 
    204                         ).with { if (!validate()) { errors.each { println it} } else save()} 
    205                         def vehicle= new ParameterStringListItem( 
    206                                 name: 'Vehicle' 
    207                         ).with { if (!validate()) { errors.each { println it} } else save()} 
    208                         def leptin= new ParameterStringListItem( 
    209                                 name: 'Leptin' 
    210                         ).with { if (!validate()) { errors.each { println it} } else save()} 
    211  
    212  
    213                         dietProtocol 
    214                         .addToParameters(new ProtocolParameter( 
    215                                 name: 'Diet', 
    216                                 type: ProtocolParameterType.STRINGLIST, 
    217                                 listEntries: [oil10,oil45])) 
    218                         .save() 
    219  
    220                         boostProtocol 
    221                         .addToParameters(new ProtocolParameter( 
    222                                 name: 'Compound', 
    223                                 type: ProtocolParameterType.STRINGLIST, 
    224                                 listEntries: [vehicle,leptin])) 
    225                         .save() 
    226  
    227                         fastingProtocol 
    228                         .addToParameters(new ProtocolParameter( 
    229                                 name: 'Fasting period', 
    230                                 type: ProtocolParameterType.STRING)) 
    231                         .save() 
    232  
    233  
    234                         // sampling event protocols 
    235  
    236                         def liverSamplingProtocol = new Protocol( 
    237                                 name: 'Liver sampling' 
    238                         ).with { if (!validate()) { errors.each { println it} } else save()} 
    239  
    240                         liverSamplingProtocol 
    241                         .addToParameters(new ProtocolParameter( 
    242                                 name: 'Sample weight', 
    243                                 unit: 'mg', 
    244                                 type: ProtocolParameterType.FLOAT)) 
    245                         .save() 
    246  
    247                         def bloodSamplingProtocol = new Protocol( 
    248                                 name: 'Blood sampling' 
    249                         ).with { if (!validate()) { errors.each { println it} } else save()} 
    250  
    251                         bloodSamplingProtocol 
    252                         .addToParameters(new ProtocolParameter( 
    253                                 name: 'Sample volume', 
    254                                 unit: 'ml', 
    255                                 type: ProtocolParameterType.FLOAT)) 
    256                         .save() 
    257  */ 
    258                         // create system user 
    259  
    260                         /*def systemUser = userService.createUser(InstanceGenerator.user( 
    261                                 username: 'system', 
    262                                 pass: 'system', 
    263                                 passConfirm: 'system', 
    264                                 enabled: true 
    265                         ))*/ 
    266  
    267  /* 
    268                         def genderField = new TemplateField( 
    269                                 name: 'Gender',type: TemplateFieldType.STRINGLIST, 
    270                                 listEntries: [new TemplateFieldListItem(name:'Male'),new TemplateFieldListItem(name: 'Female')]) 
    271                         .with { if (!validate()) { errors.each { println it} } else save()} 
    272  
    273                         def ageField = new TemplateField( 
    274                                 name: 'Age (years)',type: TemplateFieldType.INTEGER,unit: 'years') 
    275                         .with { if (!validate()) { errors.each { println it} } else save()} 
    276  
    277                         def genotypeField = new TemplateField( 
    278                                 name: 'Genotype', type: TemplateFieldType.ONTOLOGYTERM) 
    279                         .with { if (!validate()) { errors.each { println it} } else save()} 
    280  
    281                         def genotypeTypeField = new TemplateField( 
    282                                 name: 'Genotype type',type: TemplateFieldType.STRINGLIST, 
    283                                 listEntries: [new TemplateFieldListItem(name:'transgenic'), 
    284                                         new TemplateFieldListItem(name:'knock-out'), 
    285                                         new TemplateFieldListItem(name:'knock-in')]) 
    286                         .with { if (!validate()) { errors.each { println it} } else save()} 
    287  
    288  
    289                         // Nutritional study template 
    290  
    291                         println "Adding academic study template..." 
    292                         def studyTemplate = new Template( 
    293                                 name: 'Academic study', entity: dbnp.studycapturing.Study) 
    294                                 .addToFields(new TemplateField(name: 'Consortium',type: TemplateFieldType.STRING)) 
    295                                 .addToFields(new TemplateField(name: 'Cohort name',type: TemplateFieldType.STRING)) 
    296                                 .addToFields(new TemplateField(name: 'Time zone',type: TemplateFieldType.STRING)) 
    297                                 .addToFields(new TemplateField(name: 'Responsible scientist',type: TemplateFieldType.STRING)) 
    298                                 .addToFields(new TemplateField(name: 'Lab code',type: TemplateFieldType.STRING)) 
    299                                 .addToFields(new TemplateField(name: 'Institute',type: TemplateFieldType.STRING)) 
    300                         .with { if (!validate()) { errors.each { println it} } else save()} 
    301  
    302                         // Mouse template 
    303235                        def mouseTemplate = new Template( 
    304236                                name: 'Mouse', entity: dbnp.studycapturing.Subject) 
     
    324256 
    325257                        // Human template 
     258                        println ".adding human subject template..." 
    326259                        def humanTemplate = new Template( 
    327260                                name: 'Human', entity: dbnp.studycapturing.Subject) 
     
    426359 
    427360 
     361                        /* 
    428362                        //events 
    429363                        def eventDiet = new EventDescription( 
     
    466400 
    467401                        println('Adding PPS3 study...') 
    468  
     402                        */ 
    469403                        // studies 
    470404                        def exampleStudy = new Study( 
     
    488422                        ).with { if (!validate()) { errors.each { println it} } else save()} 
    489423 
    490                         def evLF = new Event( 
     424                        /*def evLF = new Event( 
    491425                                startTime: Date.parse('yyyy-MM-dd','2008-01-07'), 
    492426                                endTime: Date.parse('yyyy-MM-dd','2008-01-14'),