Changeset 57


Ignore:
Timestamp:
May 3, 2011, 2:39:38 PM (8 years ago)
Author:
robert@…
Message:
  • Added sorting for samples within an assay
  • Added UTF-8 encoding and XML declaration in export
Location:
trunk/grails-app
Files:
4 edited

Legend:

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

    r52 r57  
    8888
    8989        def update = {
     90               
    9091                // load assaySample with id specified by param.id
    9192                AssaySample assaySample = AssaySample.get( params.id as long );
     
    9798
    9899                assaySample.properties = params.sample
    99 
     100               
    100101                if( assaySample.save() ) {
    101102                        flash.message = "Sample succesfully saved";
  • trunk/grails-app/controllers/nl/tno/massSequencing/files/ExportController.groovy

    r54 r57  
    22
    33import groovy.xml.MarkupBuilder
     4import groovy.xml.StreamingMarkupBuilder
    45
    56import java.util.Date;
     
    2526                // First create zip file
    2627                ZipOutputStream zipFile = new ZipOutputStream( new BufferedOutputStream( response.getOutputStream() ) );
    27                 BufferedWriter zipWriter = new BufferedWriter( new OutputStreamWriter( zipFile ) );
     28                BufferedWriter zipWriter = new BufferedWriter( new OutputStreamWriter( zipFile, 'utf-8' ) );
    2829               
    2930                // Add the study XML file
     
    8283         */
    8384        def xml = {
    84                 def writer = new PrintWriter( response.getOutputStream() );
     85                response.contentType = "text/xml";
     86               
     87                def writer = new PrintWriter( new OutputStreamWriter( response.getOutputStream(), 'utf-8' ) );
    8588                createStudiesXML( writer )
    8689        }
     
    9396                        runObjects = Run.list()
    9497                       
    95                 def xml = new MarkupBuilder( w );
     98               
    9699                def gscfInstance = ConfigurationHolder.config.gscf.baseURL;
    97100                def sequencingInstance = ConfigurationHolder.config.grails.serverURL
    98101
    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 )
     102                def xml = new StreamingMarkupBuilder().bind {
     103                        mkp.xmlDeclaration()    // Show XML declaration on top
     104                       
     105                        sequencingData( application: 'dbNP Mass Sequencing', version: '1.0', time: new Date().dateTimeString, instance: sequencingInstance, gscfInstance: gscfInstance ) {
     106                                studies {
     107                                        studyObjects.each { studyObject ->
     108                                                study( trash: studyObject.trashcan, numAssays: studyObject.assays?.size(), numSamples: studyObject.samples?.size() ) {
     109                                                        token( studyObject.studyToken )
     110                                                        name( studyObject.name )
     111               
     112                                                        // Export all study assays
     113                                                        assays {
     114                                                                studyObject.assays?.each { assayObject ->
     115                                                                        assay( numAssaySamples: assayObject.assaySamples?.size() ) {
     116                                                                                token( assayObject.assayToken )
     117                                                                                name( assayObject.name )
     118                                                                        }
    112119                                                                }
    113120                                                        }
    114                                                 }
    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 )
     121               
     122                                                        // Export all study samples
     123                                                        samples {
     124                                                                studyObject.samples?.each { sampleObject ->
     125                                                                        sample( numAssaySamples: sampleObject.assaySamples?.size() ) {
     126                                                                                token( sampleObject.sampleToken )
     127                                                                                name( sampleObject.name )
     128                                                                        }
    122129                                                                }
    123130                                                        }
    124                                                 }
    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 )
     131               
     132                                                        // Also export all assay samples
     133                                                        assaySamples {
     134                                                                studyObject.assays*.assaySamples?.flatten().each { assaySampleObject ->
     135                                                                        assaySample( numSequences: assaySampleObject.numSequences() ) {
     136                                                                                assayToken( assaySampleObject.assay?.assayToken )
     137                                                                                sampleToken( assaySampleObject.sample?.sampleToken )
     138                                                                                runId( assaySampleObject.run?.id )
     139               
     140                                                                                fwOligo( assaySampleObject.fwOligo )
     141                                                                                fwMidName( assaySampleObject.fwMidName )
     142                                                                                fwTotalSeq( assaySampleObject.fwTotalSeq )
     143                                                                                fwMidSeq( assaySampleObject.fwMidSeq )
     144                                                                                fwPrimerSeq( assaySampleObject.fwPrimerSeq )
     145               
     146                                                                                revOligo( assaySampleObject.revOligo )
     147                                                                                revMidName( assaySampleObject.revMidName )
     148                                                                                revTotalSeq( assaySampleObject.revTotalSeq )
     149                                                                                revMidSeq( assaySampleObject.revMidSeq )
     150                                                                                revPrimerSeq( assaySampleObject.revPrimerSeq )
     151               
     152                                                                                sequenceData {
     153                                                                                        if( assaySampleObject.sequenceData ) {
     154                                                                                                assaySampleObject.sequenceData.each { sequenceDataObject ->
     155                                                                                                        file( numSequences: sequenceDataObject.numSequences ) {
     156                                                                                                                sequenceFile( sequenceDataObject.sequenceFile )
     157                                                                                                                qualityFile( sequenceDataObject.qualityFile )
     158                                                                                                        }
    152159                                                                                                }
    153160                                                                                        }
     
    155162                                                                        }
    156163                                                                }
    157                                                         }
    158                                                 } // End assay samples
    159        
     164                                                        } // End assay samples
     165               
     166                                                }
     167                                        }
     168                                } // End studies
     169                               
     170                                runs {
     171                                        runObjects.each { runObject ->
     172                                                run {
     173                                                        id( runObject.id )
     174                                                        name( runObject.name )
     175                                                        date( runObject.date )
     176                                                        machine( runObject.machine )
     177                                                        supplier( runObject.supplier )
     178                                                        parameterFile( runObject.parameterFile )
     179                                                }
    160180                                        }
    161181                                }
    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                                         }
    174                                 }
     182                               
    175183                        }
    176                        
    177                 }
     184                }       // End bind
     185               
     186                // Send XML to the writer
     187                w << xml;
    178188        }
    179189}
  • trunk/grails-app/domain/nl/tno/massSequencing/Sample.groovy

    r42 r57  
    11package nl.tno.massSequencing
     2
     3import java.util.ArrayList;
    24
    35/**
     
    3436                );
    3537        }
     38
    3639}
  • trunk/grails-app/views/assay/show.gsp

    r52 r57  
    8080                        </thead>                       
    8181                        <tbody>
    82                                 <% def assaySamples = assay.assaySamples.toList() %>
     82                                <% def assaySamples = assay.assaySamples.toList().sort { it.sample.name } %>
    8383                                <g:each in="${assaySamples}" var="assaySample">
    8484                                        <tr>
Note: See TracChangeset for help on using the changeset viewer.