Changeset 54 for trunk


Ignore:
Timestamp:
Apr 21, 2011, 12:44:44 PM (8 years ago)
Author:
robert@…
Message:
  • Improved export to include run information
  • .oligos and .tab files now contain sample names without whitespace
Location:
trunk/grails-app
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/grails-app/controllers/nl/tno/massSequencing/files/ExportController.groovy

    r53 r54  
    22
    33import groovy.xml.MarkupBuilder
     4
     5import java.util.Date;
    46import java.util.zip.ZipEntry
    57import java.util.zip.ZipOutputStream
     
    1618                // Find all studies
    1719                def studies = Study.list().findAll { it.canRead( session.user ) };
     20                def runs = Run.list();
    1821               
    1922                // Send the right headers
     
    2629                // Add the study XML file
    2730                zipFile.putNextEntry( new ZipEntry( "studies.xml" ) );
    28                 createStudiesXML( zipWriter, studies )
     31                createStudiesXML( zipWriter, studies, runs )
    2932                zipWriter.flush();
    3033                zipFile.closeEntry();
     
    3437                def buffer = new byte[ 1024 ];
    3538               
     39                // First add all sequence and quality files
    3640                studies.each { study -> study.assays?.each { assay -> assay.assaySamples?.each { assaySample -> assaySample.sequenceData?.each { data ->
    3741                        if( data ) {
     
    5458                } } } }
    5559               
     60                // Afterwards, add all parameterFiles for the runs
     61                runs.each { run ->
     62                        if( run.parameterFile ) {
     63                                // Create a zip entry for each file
     64                                // All filenames are unique, so the filenames are taken just the way they are
     65                                zipFile.putNextEntry( new ZipEntry( run.parameterFile ) );
     66                               
     67                                zipFile << new FileInputStream( fileService.get( run.parameterFile, permanentDir ) )
     68                               
     69                                // Close the zip entry
     70                                zipWriter.flush();
     71                                zipFile.closeEntry();
     72                        }
     73                }
     74               
    5675                zipFile.close();
    5776               
     
    6786        }
    6887
    69         protected void createStudiesXML( Writer w, def studies = null ) {
    70                 if( !studies )
    71                         studies = Study.list().findAll { it.canRead( session.user ) };
     88        protected void createStudiesXML( Writer w, def studyObjects = null, def runObjects = null ) {
     89                if( !studyObjects )
     90                        studyObjects = Study.list().findAll { it.canRead( session.user ) };
     91                       
     92                if( !runObjects )
     93                        runObjects = Run.list()
    7294                       
    7395                def xml = new MarkupBuilder( w );
     
    7597                def sequencingInstance = ConfigurationHolder.config.grails.serverURL
    7698
    77                 xml.studies( application: 'dbNP Mass Sequencing', version: '1.0', time: new Date().dateTimeString, instance: sequencingInstance, gscfInstance: gscfInstance ) {
    78                         studies.each { studyObject ->
    79                                 study( trash: studyObject.trashcan, numAssays: studyObject.assays?.size(), numSamples: studyObject.samples?.size() ) {
    80                                         token( studyObject.studyToken )
    81                                         name( studyObject.name )
    82 
    83                                         // Export all study assays
    84                                         assays {
    85                                                 studyObject.assays?.each { assayObject ->
    86                                                         assay( numAssaySamples: assayObject.assaySamples?.size() ) {
    87                                                                 token( assayObject.assayToken )
    88                                                                 name( assayObject.name )
     99                xml.sequencingData( application: 'dbNP Mass Sequencing', version: '1.0', time: new Date().dateTimeString, instance: sequencingInstance, gscfInstance: gscfInstance ) {
     100                        studies {
     101                                studyObjects.each { studyObject ->
     102                                        study( trash: studyObject.trashcan, numAssays: studyObject.assays?.size(), numSamples: studyObject.samples?.size() ) {
     103                                                token( studyObject.studyToken )
     104                                                name( studyObject.name )
     105       
     106                                                // Export all study assays
     107                                                assays {
     108                                                        studyObject.assays?.each { assayObject ->
     109                                                                assay( numAssaySamples: assayObject.assaySamples?.size() ) {
     110                                                                        token( assayObject.assayToken )
     111                                                                        name( assayObject.name )
     112                                                                }
    89113                                                        }
    90114                                                }
    91                                         }
    92 
    93                                         // Export all study samples
    94                                         samples {
    95                                                 studyObject.samples?.each { sampleObject ->
    96                                                         sample( numAssaySamples: sampleObject.assaySamples?.size() ) {
    97                                                                 token( sampleObject.sampleToken )
    98                                                                 name( sampleObject.name )
     115       
     116                                                // Export all study samples
     117                                                samples {
     118                                                        studyObject.samples?.each { sampleObject ->
     119                                                                sample( numAssaySamples: sampleObject.assaySamples?.size() ) {
     120                                                                        token( sampleObject.sampleToken )
     121                                                                        name( sampleObject.name )
     122                                                                }
    99123                                                        }
    100124                                                }
    101                                         }
    102 
    103                                         // Also export all assay samples
    104                                         assaySamples {
    105                                                 studyObject.assays*.assaySamples?.flatten().each { assaySampleObject ->
    106                                                         assaySample( numSequences: assaySampleObject.numSequences() ) {
    107                                                                 assayToken( assaySampleObject.assay?.assayToken )
    108                                                                 sampleToken( assaySampleObject.sample?.sampleToken )
    109 
    110                                                                 fwOligo( assaySampleObject.fwOligo )
    111                                                                 fwMidName( assaySampleObject.fwMidName )
    112                                                                 fwTotalSeq( assaySampleObject.fwTotalSeq )
    113                                                                 fwMidSeq( assaySampleObject.fwMidSeq )
    114                                                                 fwPrimerSeq( assaySampleObject.fwPrimerSeq )
    115 
    116                                                                 revOligo( assaySampleObject.revOligo )
    117                                                                 revMidName( assaySampleObject.revMidName )
    118                                                                 revTotalSeq( assaySampleObject.revTotalSeq )
    119                                                                 revMidSeq( assaySampleObject.revMidSeq )
    120                                                                 revPrimerSeq( assaySampleObject.revPrimerSeq )
    121 
    122                                                                 sequenceData {
    123                                                                         if( assaySampleObject.sequenceData ) {
    124                                                                                 assaySampleObject.sequenceData.each { sequenceDataObject ->
    125                                                                                         file( numSequences: sequenceDataObject.numSequences ) {
    126                                                                                                 sequenceFile( sequenceDataObject.sequenceFile )
    127                                                                                                 qualityFile( sequenceDataObject.qualityFile )
     125       
     126                                                // Also export all assay samples
     127                                                assaySamples {
     128                                                        studyObject.assays*.assaySamples?.flatten().each { assaySampleObject ->
     129                                                                assaySample( numSequences: assaySampleObject.numSequences() ) {
     130                                                                        assayToken( assaySampleObject.assay?.assayToken )
     131                                                                        sampleToken( assaySampleObject.sample?.sampleToken )
     132                                                                        runId( assaySampleObject.run?.id )
     133       
     134                                                                        fwOligo( assaySampleObject.fwOligo )
     135                                                                        fwMidName( assaySampleObject.fwMidName )
     136                                                                        fwTotalSeq( assaySampleObject.fwTotalSeq )
     137                                                                        fwMidSeq( assaySampleObject.fwMidSeq )
     138                                                                        fwPrimerSeq( assaySampleObject.fwPrimerSeq )
     139       
     140                                                                        revOligo( assaySampleObject.revOligo )
     141                                                                        revMidName( assaySampleObject.revMidName )
     142                                                                        revTotalSeq( assaySampleObject.revTotalSeq )
     143                                                                        revMidSeq( assaySampleObject.revMidSeq )
     144                                                                        revPrimerSeq( assaySampleObject.revPrimerSeq )
     145       
     146                                                                        sequenceData {
     147                                                                                if( assaySampleObject.sequenceData ) {
     148                                                                                        assaySampleObject.sequenceData.each { sequenceDataObject ->
     149                                                                                                file( numSequences: sequenceDataObject.numSequences ) {
     150                                                                                                        sequenceFile( sequenceDataObject.sequenceFile )
     151                                                                                                        qualityFile( sequenceDataObject.qualityFile )
     152                                                                                                }
    128153                                                                                        }
    129154                                                                                }
     
    131156                                                                }
    132157                                                        }
    133                                                 }
    134                                         } // End assay samples
    135 
     158                                                } // End assay samples
     159       
     160                                        }
     161                                }
     162                        } // End studies
     163                       
     164                        runs {
     165                                runObjects.each { runObject ->
     166                                        run {
     167                                                id( runObject.id )
     168                                                name( runObject.name )
     169                                                date( runObject.date )
     170                                                machine( runObject.machine )
     171                                                supplier( runObject.supplier )
     172                                                parameterFile( runObject.parameterFile )
     173                                        }
    136174                                }
    137175                        }
    138                 } // End studies
     176                       
     177                }
    139178        }
    140179}
  • trunk/grails-app/services/nl/tno/massSequencing/FastaService.groovy

    r52 r54  
    743743
    744744                tags.each {
    745                         zipWriter.write( "barcode\t" + it.tag + "\t" + it.uniqueName + "\n" );
     745                        // Samples names are not allowed to contain spaces
     746                        def name = it.uniqueName.replaceAll( /\s+/, '-' );
     747                        zipWriter.write( "barcode\t" + it.tag + "\t" + name + "\n" );
    746748                }
    747749        }
     
    769771
    770772                tags.each {
    771                         zipWriter.write( it.tag + "\t" + it.uniqueName + "\n" );
     773                        def name = it.uniqueName.replaceAll( /\s+/, '-' );
     774                        zipWriter.write( it.tag + "\t" + name + "\n" );
    772775                }
    773776        }
Note: See TracChangeset for help on using the changeset viewer.