source: trunk/grails-app/services/nl/tno/massSequencing/imports/ImportService.groovy @ 72

Last change on this file since 72 was 72, checked in by robert@…, 9 years ago

Implemented addition of logfiles to sequence data

File size: 4.7 KB
Line 
1package nl.tno.massSequencing.imports
2
3import groovy.lang.Closure;
4
5import java.io.File;
6import java.util.ArrayList;
7import org.codehaus.groovy.grails.commons.ConfigurationHolder
8import nl.tno.massSequencing.files.*
9import nl.tno.massSequencing.FastaService
10
11class ImportService {
12        def fileService
13        def fastaService
14        def excelService
15        def zipService
16        def classificationService
17        def mothurService
18       
19        static transactional = false
20       
21        /**
22         * Parses uploaded files and checks them for FASTA and QUAL files
23         * @param filenames             List of filenames currently existing in the upload directory
24         * @param onProgress    Closure to execute when progress indicators should be updated.
25         *                                              Has 2 parameters: progress that indicates the progress with respect to the second parameter total. This
26         *                                              might be indicated by returning the number of bytes processed and the total number of bytes that have to be processed
27         * @param directory             Directory to move the files to
28         * @return                              Structure with information about the parsed files. The 'success' files are
29         *                                              moved to the given directory
30         *
31         * [
32         *              success: [
33         *                      [filename: 'abc.fasta', type: FASTA, numSequences: 190]
34         *                      [filename: 'cde.fasta', type: FASTA, numSequences: 140]
35         *                      [filename: 'abc.qual', type: QUAL, numSequences: 190, avgQuality: 38]
36         *                      [filename: 'cde.qual', type: QUAL, numSequences: 140, avgQuality: 29]
37         *              ],
38         *              failure: [
39         *                      [filename: 'testing.xls', type: 'unknown', message: 'Type not recognized']
40         *              ]
41         * ]
42         *
43         */
44        def parseFiles( ArrayList filenames, Closure onProgress, def initialProgress, Closure newStep, File directory = null ) {
45                if( filenames.size() == 0 ) {
46                        return [ success: [], failure: [] ];
47                }
48
49                if( !directory ) {
50                        directory = fileService.absolutePath( ConfigurationHolder.config.massSequencing.fileDir )
51                }
52
53                def success = [];
54                def failure = [];
55
56                // Keep track of the current progress
57                def currentProgress = initialProgress;
58               
59                // Give the other methods a way to update the progress, by just telling how much work they have done
60                def updateProgressClosure = { progress, total ->
61                        // Update the current progress by adding the progress and total values from this file.
62                        currentProgress[ 'progress' ] += progress;
63                        currentProgress[ 'total' ] += total;
64                       
65                        onProgress( currentProgress[ 'progress' ], currentProgress[ 'total' ] );
66                }
67
68                // which importer services do we have?
69                def importerServices = [ fastaService, zipService, excelService, classificationService, mothurService ].findAll { it && it instanceof Importer }
70
71                // Loop through all filenames and find a service to handle this file
72                for( int i = 0; i < filenames.size(); i++ ) {
73                        def parsed = false;
74                        def filename = filenames[ i ]
75                        def file = fileService.get( filename );
76                        String filetype = fileService.determineFileType( file );
77
78                        // Search which importer service is capable of handling this file. If none is capable,
79                        // discard the file and report back to the user
80                        for( service in importerServices ) {
81                                if( service.canParseFileType( filetype ) ) {
82                                        try {
83                                                // Parse the file
84                                                def contents = service.parseFile( file, filetype, updateProgressClosure );
85                                               
86                                                contents.filename = file.getName();
87                                                contents.originalfilename = fileService.originalFilename( contents.filename )
88                                               
89                                                if( contents.success ) {
90                                                        success << contents;
91                                                       
92                                                        // If new files are retrieved, put them in the list
93                                                        if( contents.extraFiles ) {
94                                                                contents.extraFiles.each {
95                                                                        filenames.add( it );
96                                                                }
97                                                               
98                                                        }
99                                                } else {
100                                                        fileService.delete(filename);
101                                                        failure << contents;
102                                                }
103                                        } catch( Exception e ) {
104                                                e.printStackTrace();
105                                               
106                                                // If anything fails during parsing, return an error message
107                                                fileService.delete(filename);
108                                                failure << [ filename: filename, originalfilename: fileService.originalFilename( filename ), type: filetype, message: e.getMessage() ];
109                                        }
110                                       
111                                        parsed = true;
112                                        break;  // out of the services loop: the other services don't have to parse this file
113                                }
114                        }
115                       
116                        // If the file couldn't be parsed by any service, return it to the user
117                        if( !parsed ) {
118                                // Update progress since we don't have to handle this file
119                                currentProgress[ 'progress' ] += file.size()
120                                onProgress( currentProgress[ 'progress' ], currentProgress[ 'total' ] );
121                               
122                                // If files are not valid for parsing, delete them and return a message to the user
123                                fileService.delete(filename);
124                                failure << [ filename: filename, originalfilename: fileService.originalFilename( filename ), type: filetype, message: 'File type not accepted' ];
125                        }       
126                }
127
128                return [ 'success': success, 'failure': failure ];
129        }
130
131}
Note: See TracBrowser for help on using the repository browser.