source: trunk/grails-app/controllers/nl/tno/massSequencing/files/ExportController.groovy @ 63

Last change on this file since 63 was 57, checked in by robert@…, 9 years ago
  • Added sorting for samples within an assay
  • Added UTF-8 encoding and XML declaration in export
File size: 5.9 KB
Line 
1package nl.tno.massSequencing.files
2
3import groovy.xml.MarkupBuilder
4import groovy.xml.StreamingMarkupBuilder
5
6import java.util.Date;
7import java.util.zip.ZipEntry
8import java.util.zip.ZipOutputStream
9import nl.tno.massSequencing.*;
10import org.codehaus.groovy.grails.commons.ConfigurationHolder
11
12class ExportController {
13        def fileService
14       
15        /**
16         * Exports all studies to XML
17         */
18        def zip = {
19                // Find all studies
20                def studies = Study.list().findAll { it.canRead( session.user ) };
21                def runs = Run.list();
22               
23                // Send the right headers
24                response.setHeader "Content-disposition", "attachment; filename=sequencing_studies.zip"
25               
26                // First create zip file
27                ZipOutputStream zipFile = new ZipOutputStream( new BufferedOutputStream( response.getOutputStream() ) );
28                BufferedWriter zipWriter = new BufferedWriter( new OutputStreamWriter( zipFile, 'utf-8' ) );
29               
30                // Add the study XML file
31                zipFile.putNextEntry( new ZipEntry( "studies.xml" ) );
32                createStudiesXML( zipWriter, studies, runs )
33                zipWriter.flush();
34                zipFile.closeEntry();
35               
36                // Add all other files. These files are stored in the directory given in the configuration
37                def permanentDir = fileService.absolutePath( ConfigurationHolder.config.massSequencing.fileDir );
38                def buffer = new byte[ 1024 ];
39               
40                // First add all sequence and quality files
41                studies.each { study -> study.assays?.each { assay -> assay.assaySamples?.each { assaySample -> assaySample.sequenceData?.each { data ->
42                        if( data ) {
43                                // Loop through all sequence- and quality files.
44                                def files = [ data.sequenceFile, data.qualityFile ];
45                                files.each { filename ->
46                                        if( filename ) {
47                                                // Create a zip entry for each file
48                                                // All filenames are unique, so the filenames are taken just the way they are
49                                                zipFile.putNextEntry( new ZipEntry( filename ) );
50                                               
51                                                zipFile << new FileInputStream( fileService.get( filename, permanentDir ) )
52                                               
53                                                // Close the zip entry
54                                                zipWriter.flush();
55                                                zipFile.closeEntry();
56                                        } 
57                                }
58                        }
59                } } } }
60               
61                // Afterwards, add all parameterFiles for the runs
62                runs.each { run ->
63                        if( run.parameterFile ) {
64                                // Create a zip entry for each file
65                                // All filenames are unique, so the filenames are taken just the way they are
66                                zipFile.putNextEntry( new ZipEntry( run.parameterFile ) );
67                               
68                                zipFile << new FileInputStream( fileService.get( run.parameterFile, permanentDir ) )
69                               
70                                // Close the zip entry
71                                zipWriter.flush();
72                                zipFile.closeEntry();
73                        }
74                }
75               
76                zipFile.close();
77               
78                response.outputStream.flush();
79        }
80
81        /**
82         * Exports all studies to XML
83         */
84        def xml = {
85                response.contentType = "text/xml";
86               
87                def writer = new PrintWriter( new OutputStreamWriter( response.getOutputStream(), 'utf-8' ) );
88                createStudiesXML( writer )
89        }
90
91        protected void createStudiesXML( Writer w, def studyObjects = null, def runObjects = null ) {
92                if( !studyObjects )
93                        studyObjects = Study.list().findAll { it.canRead( session.user ) };
94                       
95                if( !runObjects )
96                        runObjects = Run.list()
97                       
98               
99                def gscfInstance = ConfigurationHolder.config.gscf.baseURL;
100                def sequencingInstance = ConfigurationHolder.config.grails.serverURL
101
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                                                                        }
119                                                                }
120                                                        }
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                                                                        }
129                                                                }
130                                                        }
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                                                                                                        }
159                                                                                                }
160                                                                                        }
161                                                                                }
162                                                                        }
163                                                                }
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                                                }
180                                        }
181                                }
182                               
183                        }
184                }       // End bind
185               
186                // Send XML to the writer
187                w << xml;
188        }
189}
Note: See TracBrowser for help on using the repository browser.