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

Last change on this file since 54 was 54, checked in by robert@…, 9 years ago
  • Improved export to include run information
  • .oligos and .tab files now contain sample names without whitespace
File size: 5.6 KB
Line 
1package nl.tno.massSequencing.files
2
3import groovy.xml.MarkupBuilder
4
5import java.util.Date;
6import java.util.zip.ZipEntry
7import java.util.zip.ZipOutputStream
8import nl.tno.massSequencing.*;
9import org.codehaus.groovy.grails.commons.ConfigurationHolder
10
11class ExportController {
12        def fileService
13       
14        /**
15         * Exports all studies to XML
16         */
17        def zip = {
18                // Find all studies
19                def studies = Study.list().findAll { it.canRead( session.user ) };
20                def runs = Run.list();
21               
22                // Send the right headers
23                response.setHeader "Content-disposition", "attachment; filename=sequencing_studies.zip"
24               
25                // First create zip file
26                ZipOutputStream zipFile = new ZipOutputStream( new BufferedOutputStream( response.getOutputStream() ) );
27                BufferedWriter zipWriter = new BufferedWriter( new OutputStreamWriter( zipFile ) );
28               
29                // Add the study XML file
30                zipFile.putNextEntry( new ZipEntry( "studies.xml" ) );
31                createStudiesXML( zipWriter, studies, runs )
32                zipWriter.flush();
33                zipFile.closeEntry();
34               
35                // Add all other files. These files are stored in the directory given in the configuration
36                def permanentDir = fileService.absolutePath( ConfigurationHolder.config.massSequencing.fileDir );
37                def buffer = new byte[ 1024 ];
38               
39                // First add all sequence and quality files
40                studies.each { study -> study.assays?.each { assay -> assay.assaySamples?.each { assaySample -> assaySample.sequenceData?.each { data ->
41                        if( data ) {
42                                // Loop through all sequence- and quality files.
43                                def files = [ data.sequenceFile, data.qualityFile ];
44                                files.each { filename ->
45                                        if( filename ) {
46                                                // Create a zip entry for each file
47                                                // All filenames are unique, so the filenames are taken just the way they are
48                                                zipFile.putNextEntry( new ZipEntry( filename ) );
49                                               
50                                                zipFile << new FileInputStream( fileService.get( filename, permanentDir ) )
51                                               
52                                                // Close the zip entry
53                                                zipWriter.flush();
54                                                zipFile.closeEntry();
55                                        } 
56                                }
57                        }
58                } } } }
59               
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               
75                zipFile.close();
76               
77                response.outputStream.flush();
78        }
79
80        /**
81         * Exports all studies to XML
82         */
83        def xml = {
84                def writer = new PrintWriter( response.getOutputStream() );
85                createStudiesXML( writer )
86        }
87
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()
94                       
95                def xml = new MarkupBuilder( w );
96                def gscfInstance = ConfigurationHolder.config.gscf.baseURL;
97                def sequencingInstance = ConfigurationHolder.config.grails.serverURL
98
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                                                                }
113                                                        }
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 )
122                                                                }
123                                                        }
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 )
152                                                                                                }
153                                                                                        }
154                                                                                }
155                                                                        }
156                                                                }
157                                                        }
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                                        }
174                                }
175                        }
176                       
177                }
178        }
179}
Note: See TracBrowser for help on using the repository browser.