source: trunk/grails-app/controllers/nl/tno/metagenomics/RunController.groovy @ 9

package nl.tno.metagenomics

import java.util.Date;

import org.codehaus.groovy.grails.commons.ConfigurationHolder

class RunController {
        def fileService
        def synchronizationService
        def sampleExcelService

        def index = {
                [runs: Run.list()]
        }

        def show = {
                // load run with id specified by param.id
                def run = getRun( params.id );

                if (!run) {
                        redirect(controller: 'study', action: 'index')
                        return
                }

                // Make sure the newest data is available
                synchronizationService.sessionToken = session.sessionToken
                synchronizationService.synchronizeStudies();

                // Determine runs not used in this assay
                def otherAssays = Assay.list( sort: "name" ).findAll { !it.runs.contains( run ) }

                // Send the assay information to the view
                [run: run, allRuns: Run.list(), otherAssays: otherAssays, editable: true]
        }

        /**
         * Shows a form to edit the specified run in dialog mode
         */
        def editForm = {
                // load run with id specified by param.id
                Run run = getRun( params.id );

                if (!run) {
                        render flash.error
                        return
                }
                
                Assay assay = null
                if( params.assayId ) {
                        assay = getAssay( params.assayId )
        
                        if( !assay ) {
                                render flash.error;
                                return
                        }
                }

                [assay: assay, run: run]
        }

        def create = {
                Assay a = getAssay(params.id);
                flash.error = "";

                // Create run based on given parameters
                Run run = new Run();

                run.setPropertiesFromForm( params );

                if( a )
                        a.addToRuns( run );

                if( !run.save() ) {
                        flash.message = "Run could not be saved: " + run.getErrors();
                } else {
                        flash.message = "Run " + run.name + " has been added to the system."
                }

                if( a )
                        redirect( controller: "assay", action: "show", id: a.id )
                else
                        redirect( controller: 'run' );
        }

        def update = {
                Run run = getRun( params.id );

                if( !run ) {
                        redirect(controller: 'assay', action: 'show', id: params.assayId)
                        return
                }

                // Set properties to the run
                params.parameterFile = params.editParameterFile
                
                println "Edit run: " + params
                run.setPropertiesFromForm( params );

                if( run.save() ) {
                        flash.message = "Run succesfully saved";
                } else {
                        flash.error = "Run could not be saved: " + run.getErrors();
                }
                
                Assay assay = getAssay(params.assayId);
                flash.error = "";
                
                if( assay ) {
                        redirect( controller: 'assay', action: 'show', id: assay.id)
                } else {
                        redirect( controller: 'run', action: 'show', id: run.id )
                }
        }

        def delete = {
                Run run = getRun( params.id );

                if( !run ) {
                        redirect(controller: 'assay', action: 'show', id: params.assayId)
                        return
                }

                // Don't remove runs for which data exists
                if( run.sequenceData?.size() ) {
                        flash.message = "Run could not be deleted because samples are associated with it.";
                        redirect( controller: "assay", action: "show", id: params.assayId )
                }

                // Remove all associations
                run.assays.each {
                        run.removeFromAssays( it );
                }

                def name = run.name
                run.delete();
                flash.message = "Run " + name + " has been deleted from the system."

                redirect( controller: "assay", action: "show", id: params.assayId )
        }

        /**************************************************************************
         *
         * Methods for handling data about the samples in this run
         *
         *************************************************************************/

        /**
         * Downloads an excel sheet with data about the assay samples, to enter data in excel
         */
        def downloadTagsExcel = {
                Run run = getRun( params.id );

                if( !run ) {
                        redirect(controller: 'study')
                        return
                }

                // Make it only possible to update samples writable by the user
                def assaySamples = run.assaySamples.findAll { it.assay.study.canWrite( session.user ) }

                def filename = "Run " + run.name + "_tags.xls"
                def wb = sampleExcelService.downloadSampleExcel( assaySamples, false );

                // Make file downloadable
                log.trace( "Creation for downloading the file " + filename )
                sampleExcelService.excelService.downloadFile( wb, filename, response )
        }


        /**
         * Parses an uploaded excel file and shows a form to match columns
         */
        def parseTagExcel = {
                Run run = getRun( params.id );

                if( !run ) {
                        redirect(controller: 'study')
                        return
                }

                def filename = params.filename

                // Security check to prevent accessing files in other directories
                if( !filename || filename.contains( '..' ) ) {
                        response.status = 500;
                        render "Invalid filename given";
                        return;
                }

                // Check for existence and readability
                File file = new File( fileService.getUploadDir(), filename)

                if( !file.exists() || !file.canRead() ) {
                        response.status = 404;
                        render "The uploaded file doesn't exist or doesn't work as expected.";
                        return;
                }

                // Save the filename in session for later use
                session.filename = filename;
                def excelData;
                try {
                        excelData = sampleExcelService.parseTagsExcel( file, false );
                } catch( Throwable e ) { // Catch a throwable here instead of an exception, since the apache poi stuff gives an Error on failure
                        // Couldn't create a workbook from this file.
                        response.status = 400 // Bad request
                        render "Uploaded file is not a valid excel file: " + e.getMessage()
                        return
                }
                session.possibleFields = excelData.possibleFields

                [run: run, headers: excelData.headers, exampleData: excelData.exampleData, filename: filename, possibleFields: [ "Don't import" ] + excelData.possibleFields, bestMatches: excelData.bestMatches]
        }

        /**
         * Updates the assay samples based on the given excel file and the column matches
         */
        def updateTagsByExcel = {
                Run run = getRun( params.id );

                if( !run ) {
                        // Now delete the file, since we don't need it anymore
                        _deleteUploadedFileFromSession()

                        redirect(controller: 'study')
                        return
                }

                if( !session.filename ) {
                        // Now delete the file, since we don't need it anymore
                        _deleteUploadedFileFromSession()

                        flash.error = "No excel file found because session timed out. Please try again."
                        redirect( action: 'show', id: params.id)
                        return
                }

                // Determine the match-columns
                def matchColumns = params[ 'matches'];

                // Now loop through the excel sheet and update all samples with the specified data
                File file = new File( fileService.getUploadDir(), session.filename );

                if( !file.exists() || !file.canRead() ) {
                        flash.error = "Excel file has been removed since previous step. Please try again."
                        redirect( action: 'show', id: params.id)
                        return
                }
                
                // Make it only possible to update samples writable by the user
                def assaySamples = run.assaySamples.findAll { it.assay.study.canWrite( session.user ) }
                
                def excelData = sampleExcelService.updateTagsByExcel( matchColumns, session.possibleFields, file, assaySamples );

                // Return a message to the user
                if( !excelData.success ) {
                        flash.error = excelData.message
                } else if( excelData.numSuccesful == 0 ) {
                        flash.error = "None of the " + excelData.failedRows.size() + " row(s) could be imported, because none of the sample names matched or no samples are writable. Have you provided the right excel file?"
                } else {
                        flash.message = excelData.numSuccesful + " samples have been updated. "

                        if( excelData.failedRows.size() > 0 )
                                flash.message += excelData.failedRows.size() + " row(s) could not be imported, because the sample names could not be found in the database or you don't have the proper permissions to change them."
                }
                redirect( action: 'show', id: params.id )
        }


        /**
         * Update the properties of the assay samples manually
         */
        def updateTagsManually = {
                Run run = getRun( params.id );

                if( !run ) {
                        redirect(controller: 'study')
                        return
                }

                // Loop through all assay samples and set data
                def sampleParams = params.assaySample;

                if( sampleParams ) {
                        run.assaySamples.each { assaySample ->
                                def assaySampleParams = sampleParams.get( assaySample.id as String );
                                if( assaySampleParams ) {
                                        assaySample.tagName = assaySampleParams.tagName
                                        assaySample.oligoNumber = assaySampleParams.oligoNumber
                                        assaySample.tagSequence = assaySampleParams.tagSequence

                                        assaySample.save()
                                }
                        }
                }

                flash.message = "Data about samples is saved."
                redirect( action: 'show', id: params.id )
        }

        /**************************************************************************
         *
         * Methods for handling data about assays for this run
         *
         *************************************************************************/

        /**
         * Adds existing assays to this run
         */
        def addAssays = {
                Run run = getRun( params.id );

                if( !run ) {
                        redirect(controller: 'study')
                        return
                }

                // Add checked runs to this assay
                def assays = params.assays
                if( assays instanceof String ) {
                        assays = [ assays ]
                }

                def numAdded = 0;
                assays.each { assay_id ->
                        try {
                                def assay = Assay.findById( assay_id as Long )
                                if( run.assays == null || !run.assays.contains( assay ) ) {
                                        run.addToAssays( assay );
                                        numAdded++;
                                }
                        } catch( Exception e ) {}
                }

                flash.message = numAdded + " runs are added to this assay."
                redirect( action: 'show', id: params.id)
        }

        /**
         * Removes assay for this run
         */
        def removeAssay = {
                Run run = getRun( params.id );

                if( !run ) {
                        redirect(controller: 'study')
                        return
                }
                
                if( !params.assay_id ) {
                        flash.message = "No assay id given"
                        redirect(action: 'show', id: params.id)
                        return
                }

                def assay

                try {
                        assay = Assay.findById( params.assay_id as Long )
                } catch( Exception e ) {
                        throw e
                        flash.message = "Incorrect assay id given: "
                        redirect(action: 'show', id: params.id)
                        return
                }

                if( run.assays.contains( assay ) ) {
                        run.removeFromAssays( assay );
                        flash.message = "The assay has been removed from this run."
                } else {
                        flash.message = "The given assay was not associated with this run."
                }

                redirect( action: 'show', id: params.id)
        }


        /**
         * Deletes an uploaded file for which the filename is given in the session.
         * @return
         */
        def _deleteUploadedFileFromSession() {
                if( !session.filename )
                        return

                // Now delete the file, since we don't need it anymore
                fileService.delete( session.filename  )
                session.filename = ''
        }

        protected Run getRun(def runId) {
                // load study with id specified by param.id
                def run
                try {
                        run = Run.get(runId as Long)
                } catch( Exception e ) {
                        flash.error = "Incorrect id given: " + runId
                        return null
                }

                if (!run) {
                        flash.error = "No run found with id: " + runId
                        return null
                }

                return run
        }

        protected Assay getAssay(def assayId) {
                // load study with id specified by param.id
                def assay
                try {
                        assay = Assay.get(assayId as Long)
                } catch( Exception e ) {
                        flash.error = "Incorrect id given: " + assayId
                        return null
                }

                if (!assay) {
                        flash.error = "No assay found with id: " + assayId
                        return null
                }

                if (!assay.study.canRead( session.user ) ) {
                        flash.error = "You don't have the right authorizaton to access assay " + assay.name
                        return null
                }

                return assay
        }
}