Ignore:
Timestamp:
May 17, 2011, 1:44:07 PM (9 years ago)
Author:
robert@…
Message:

Implemented importing of classifications

File:
1 copied

Legend:

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

    r57 r58  
    1 package nl.tno.massSequencing
     1package nl.tno.massSequencing.files
    22
    33import org.codehaus.groovy.grails.commons.ConfigurationHolder
    44import org.hibernate.SessionFactory
    55import grails.converters.*;
    6 
    7 class FastaController {
     6import nl.tno.massSequencing.*
     7
     8class ImportController {
    89        def fileService
    910        def fastaService
     11        def importService
     12        def classificationService
    1013        def sessionFactory
    1114       
    1215        /**************************************************************************
    1316         *
    14          * Methods for handling uploaded sequence and quality files
     17         * Methods for handling uploaded sequence, quality and classification files
    1518         *
    1619         *************************************************************************/
     
    2326
    2427                // Check whether files are given
    25                 def names = params.sequencefiles
     28                def names = params.list( 'sequencefiles' )
    2629
    2730                if( !names ) {
     
    3437                        return
    3538                }
    36                
    37                 // If only 1 file is uploaded, it is given as String
    38                 ArrayList filenames = []
    39                 if( names instanceof String )
    40                         filenames << names
    41                 else
    42                         names.each { filenames << it }
    4339                       
    4440                // Save filenames in session
     
    5147                        filesize += fileService.get( it )?.length()
    5248                }
     49
    5350                session.processProgress = [
    54                         numFiles: names.size(),
    55                         numBytes: filesize,
    56                         filesProcessed: 0,
    57                         bytesProcessed: 0
     51                        stepNum: 1,
     52                        numSteps: 2,
     53                        stepDescription: 'Parsing files',       // Second step is Store classification
     54                       
     55                        stepProgress: 0,
     56                        stepTotal: filesize
    5857                ]
    5958                       
     
    7170                        case "run":
    7271                                entity = getRun( params.id );
    73                                 assaySamples = entity.assaySamples.findAll { it.assay.study.canRead( session.user ) };
     72                                assaySamples = entity.assaySamples.findAll { it.assay.study.canWrite( session.user ) };
    7473                                break;
    7574                        case "assay":
    7675                                entity = getAssay( params.id );
    77                                 assaySamples = entity.assaySamples;
     76                                assaySamples = entity.assaySamples.findAll { it.assay.study.canWrite( session.user ) };
    7877                                break;
    7978                        default:
     
    115114                 *              ],
    116115                 *              failure: [
    117                  *                      [filename: 'testing.xls', message: 'Type not recognized']
     116                 *                      [filename: 'testing.doc', message: 'Type not recognized']
    118117                 *              ]
    119118                 * ]
     
    122121                 */
    123122                def httpSession = session;
    124                 def parsedFiles = fastaService.parseFiles( filenames, { files, bytes, totalFiles, totalBytes ->
    125                         httpSession.processProgress.numFiles += totalFiles;
    126                         httpSession.processProgress.numBytes += totalBytes;
    127                         httpSession.processProgress.filesProcessed = files;
    128                         httpSession.processProgress.bytesProcessed = bytes;
    129                 } );
    130                
    131                 // Check which assaySamples to use (only the ones visible to the user)
    132                 assaySamples = assaySamples.findAll { it.assay.study.canWrite( session.user ) }
    133 
     123                def onProgress = { progress, total ->
     124                        // Update progress
     125                        httpSession.processProgress.stepTotal = total;
     126                        httpSession.processProgress.stepProgress = progress;
     127                }
     128                def newStep = { total, description ->
     129                        // Start a new step
     130                        httpSession.processProgress.stepTotal = total;
     131                        httpSession.processProgress.stepProgress = 0;
     132                       
     133                        httpSession.processProgress.stepDescription = description;
     134                        httpSession.processProgress.stepNum++;
     135                }
     136
     137                def parsedFiles = importService.parseFiles( filenames, onProgress, [progress: 0, total: httpSession.processProgress.stepTotal ], newStep );
     138               
     139                println "Parsed files success: " + parsedFiles.success
     140               
     141                // Determine excel matches from the uploaded files
     142                parsedFiles.success = fastaService.inferExcelMatches( parsedFiles.success );
     143               
     144                // Now check whether a taxonomy and groups file are uploaded. If so send them to the classificationService for
     145                // parsing
     146                def classificationFiles = parsedFiles.success.findAll { it.type == 'groups' || it.type == 'taxonomy' };
     147                def excelFiles = parsedFiles.success.findAll { it.type == 'excel' }
     148                def excelMatches = [:]
     149               
     150                // Find a match between input (mothur) samples and the samples in the system
     151                excelFiles.each { excelFile ->
     152                        if( excelFile.matches && excelFile.matches[ 'mothursamples' ] ) {
     153                                excelFile.matches[ 'mothursamples' ].each { excelMatch ->
     154                                        def foundSample = assaySamples.find { it.sample.name == excelMatch.samplename };
     155                                        if( foundSample )
     156                                                excelMatches[ excelMatch.mothurname ] = foundSample
     157                                }
     158                        }
     159                }
     160               
     161                if( classificationFiles ) {
     162                        parsedFiles.success -= classificationFiles;
     163
     164                        // If no excel matches are found, no classifications can be stored
     165                        if( !excelMatches ) {
     166                                classificationFiles.each {
     167                                        it.success = false
     168                                        it.message = "An excel file which maps the input samples with samples in the system must be provided."
     169                                       
     170                                        parsedFiles.failure << it;
     171                                }
     172                        } else {
     173                                // Set progress to a new step, so the user knows that it will take a while
     174                                long totalSize = classificationFiles.collect { it.filesize }.sum();
     175                                newStep( totalSize, "Storing classification" )
     176                                println "Total size: " + totalSize;
     177                               
     178                                classificationFiles = classificationService.storeClassification( classificationFiles, excelMatches, { bytesProcessed -> httpSession.processProgress.stepProgress += bytesProcessed } );
     179                               
     180                                classificationFiles.each {
     181                                        if( it.success ) {
     182                                                parsedFiles.success << it;
     183                                        } else {
     184                                                parsedFiles.failure << it;
     185                                        }
     186                                }
     187                        }
     188                }
     189               
    134190                // Match files with samples in the database
    135191                def matchedFiles = fastaService.matchFiles( parsedFiles.success, assaySamples );
     
    139195
    140196                // Saved file matches in session to use them later on
    141                 session.processedFiles = [ parsed: parsedFiles, matched: matchedFiles ];
     197                session.processedFiles = [ parsed: parsedFiles,  matched: matchedFiles ];
    142198
    143199                render ""
     
    186242                }
    187243               
    188                 [entityType: params.entityType, entity: entity, id: params.id, parsedFiles: session.processedFiles.parsed, matchedFiles: session.processedFiles.matched, selectedRun: params.selectedRun ]
     244                [entityType: params.entityType, entity: entity, id: params.id, parsedFiles: session.processedFiles.parsed, classificationFiles: session.processedFiles.parsed.success.findAll { it.type == 'taxonomy' }, matchedFiles: session.processedFiles.matched, selectedRun: params.selectedRun ]
    189245        }
    190246
     
    252308                def errors = [];
    253309               
    254                 // Loop through all files Those are the numeric elements in the 'files' array
     310                // Loop through all files. Those are the numeric elements in the 'files' array
    255311                def digitRE = ~/^\d+$/;
    256312                files.findAll { it.key.matches( digitRE ) }.each { file ->
Note: See TracChangeset for help on using the changeset viewer.