Changeset 13 for trunk/grails-app/services/nl

Timestamp:

Feb 10, 2011, 5:03:02 PM (12 years ago)

Author:

robert@…

Message:

Improved user interface and implemented basic export functionality

Location:

trunk/grails-app/services/nl/tno/metagenomics

Files:

• FastaService.groovy (modified) (4 diffs)
• SampleExcelService.groovy (modified) (5 diffs)
• files/FileService.groovy (modified) (1 diff)
• integration/GscfService.groovy (modified) (8 diffs)
• integration/SynchronizationService.groovy (modified) (1 diff)

trunk/grails-app/services/nl/tno/metagenomics/FastaService.groovy

@@ -3 +3 @@
 import java.io.BufferedWriter;
 import java.io.File;
+import java.io.Writer;
 import java.util.ArrayList;
 import java.util.zip.ZipEntry
@@ -11 +12 @@
         def fileService
         def fuzzySearchService
+        def sampleExcelService
 
         static transactional = true
@@ -428 +430 @@
 
                                 // Save the tag for exporting
-                                tags << [assaySampleId: assaySample.id, sampleName: assaySample.sample.name, assayName: assaySample.assay.name, tag: tag]
+                                tags << [assaySampleId: assaySample.id, sampleName: assaySample.sample.name, assayName: assaySample.assay.name, studyName: assaySample.assay.study.name, tag: tag]
                         }
                 }
@@ -481 +483 @@
                 }
                 
+                // Export a tab delimited file with tags
+                zipFile.putNextEntry( new ZipEntry( name + "_sample-tag.tab" ) );
+                exportSampleTagFile( tags, zipWriter );
+                zipWriter.flush();
+                zipFile.closeEntry();
+
+                // Export an excel file with information about the samples
+                zipFile.putNextEntry( new ZipEntry( name + ".xls" ) );
+                sampleExcelService.exportExcelSampleData( assaySamples, tags, zipFile );
+                zipFile.closeEntry();
+                
                 zipFile.close();
-
-                // Export a tab delimited file with tags
-                //exportSampleTagFile( tags );
+        }
+        
+        /**
+         * Creates a tab delimited file with two columns and column headers "Sequence" and "Samplename"
+         * @param tags          Map with newly created tags
+         * @param zipWriter     Writer to write the data to
+         */
+        protected void exportSampleTagFile( List tags, Writer zipWriter ) {
+                zipWriter.write( "Sequence" + "\t" + "Samplename" + "\n" );
+                
+                // Check whether the sample names are unique. If they aren't, the assay and study names
+                // are appended to the sample name
+                def sampleNames = tags*.sampleNames;
+                if( sampleNames.unique().size() < sampleNames.size() ) {
+                        tags.each {
+                                it.uniqueName = it.sampleName + " (" + it.assayName + " / " + it.studyName + ")";
+                        }
+                } else {
+                        tags.each {
+                                it.uniqueName = it.sampleName;
+                        }
+                }
+                
+                tags.each {
+                        zipWriter.write( it.tag + "\t" + it.uniqueName + "\n" );
+                }
         }
 

trunk/grails-app/services/nl/tno/metagenomics/SampleExcelService.groovy

@@ -1 +1 @@
 package nl.tno.metagenomics
+
+import org.springframework.web.context.request.RequestContextHolder;
 
 class SampleExcelService {
         def excelService
         def fuzzySearchService
+        def gscfService
         
     static transactional = true
@@ -15 +18 @@
         def possibleFields = [sampleNameName, runName, tagNameName, tagSequenceName, oligoNumberName]
         
-    def downloadSampleExcel( def assaySamples, boolean includeRun = true ) {
+    /**
+     * Download a sample excel file with information about the metagenomics data of the assaySamples (i.e. all assaySample properties)
+     * @param assaySamples      AssaySamples for which the information should be exported
+     * @param includeRun        Whether to include a column with run name or not
+     * @return
+     */
+        def downloadSampleExcel( def assaySamples, boolean includeRun = true ) {
                 def sheetIndex = 0;
                 
@@ -50 +59 @@
                 excelService.autoSizeColumns( wb, sheetIndex, 0..2)
 
-                return wb;              
+                return wb;
     }
         
+        /**
+         * Parses a given excel file and tries to match the column names with assaySample properties
+         * @param file  
+         * @return
+         */
         def parseTagsExcel( File file, boolean includeRun = true ) {
                 def sheetIndex = 0
@@ -81 +95 @@
         }
         
+        /**
+         * Updates given assay samples with data from the excel file
+         * @param matchColumns          Indicated which columns from the excel file should go into which field of the assaySample
+         * @param possibleFields        List with possible fields to enter
+         * @param file                          Excel file with the data
+         * @param assaySamples          Assay Samples to be updated
+         * @return
+         */
         def updateTagsByExcel( def matchColumns, def possibleFields, File file, def assaySamples ) {
                 def sheetIndex = 0
@@ -187 +209 @@
                 }
         }
+        
+        /**
+         * Exports all known data about the samples to an excel file
+         * @param assaySamples  Assaysamples to export information about
+         * @param tags                  Tags associated with the assay samples
+         * @param stream                Outputstream to write the data to       
+         * @return
+         */
+        def exportExcelSampleData( List<AssaySample> assaySamples, def tags, OutputStream stream ) {
+                if( assaySamples == null )
+                        assaySamples = []
+
+                // Gather data from GSCF.
+                def sampleTokens = assaySamples*.sample.unique()*.sampleToken;
+                def sessionToken = RequestContextHolder.currentRequestAttributes().getSession().sessionToken
+                def gscfData
+                try {
+                        gscfData = gscfService.getSamples( sessionToken, sampleTokens );
+                } catch( Exception e ) {
+                        log.error "Exception occurred while fetching sample data from gscf: " + e.getMessage();
+                        return;
+                }
+                
+                // Determine which fields to show from the GSCF data
+                def gscfFields = []
+                def subjectFields = []
+                def eventFields = []
+                def moduleFields = [ "Sample name", "Assay name", "Study name", "Run name", "# sequences", "Artificial tag sequence", "Original tag sequence", "Tag name", "Oligo number" ]
+                gscfData.each { sample ->
+                        sample.each { key, value ->
+                                if( key == "subjectObject" ) {
+                                        value.each { subjectKey, subjectValue -> 
+                                                if( subjectValue && !value.isNull( subjectKey ) && !subjectFields.contains( subjectKey ) )
+                                                        subjectFields << subjectKey
+                                        }
+                                } else if( key == "eventObject" ) {
+                                        value.each { eventKey, eventValue -> 
+                                                if( eventValue && !value.isNull( eventKey ) && !eventFields.contains( eventKey ) )
+                                                        eventFields << eventKey
+                                        }
+                                } else if( value && !sample.isNull( key ) && !gscfFields.contains( key ) ) {
+                                        gscfFields << key
+                                }
+                        }
+                }
+                
+                // Handle specific fields and names in GSCF
+                def fields = handleSpecificFields( [ "module": moduleFields, "gscf": gscfFields, "subject": subjectFields, "event": eventFields ] );
+
+                // Put the module data in the right format (and sorting the samples by name)
+                def data = []
+                assaySamples.toList().sort { it.sample.name }.each { assaySample ->
+                        // Lookup the tag for this assaySample
+                        def currentTag = tags.find { it.assaySampleId == assaySample.id };
+                        
+                        // First add the module data
+                        def row = [
+                                assaySample.sample.name,
+                                assaySample.assay.name,
+                                assaySample.assay.study.name,
+                                assaySample.run?.name,
+                                assaySample.numSequences(),
+                                currentTag?.tag,
+                                assaySample.tagName,
+                                assaySample.tagSequence,
+                                assaySample.oligoNumber
+                        ]
+                        
+                        // Afterwards add the gscfData including subject and event data
+                        def gscfRow = gscfData.find { it.sampleToken == assaySample.sample.sampleToken };
+                        if( gscfRow ) {
+                                fields[ "names" ][ "gscf" ].each { field ->
+                                        row << prepare( gscfRow, field );
+                                }
+                                fields[ "names" ][ "subject" ].each { field ->
+                                        row << prepare( gscfRow.optJSONObject( "subjectObject" ), field );
+                                }
+                                fields[ "names" ][ "event" ].each { field ->
+                                        row << prepare( gscfRow.optJSONObject( "eventObject" ), field );
+                                }
+                        }
+                        
+                        data << row;
+                        
+                }
+                
+                // Create excel file
+                def sheetIndex = 0;
+                        
+                // Create an excel sheet
+                def wb = excelService.create();
+
+                // Put the headers on the first row
+                excelService.writeHeader( wb, fields[ "descriptions" ][ "all" ], sheetIndex );
+                excelService.writeData( wb, data, sheetIndex, 1 );
+
+                // Auto resize columns
+                excelService.autoSizeColumns( wb, sheetIndex, 0..fields[ "names" ][ "all" ].size()-1)
+
+                // Write the data to the output stream
+                wb.write( stream );
+        }
+        
+        protected String prepare( def object, def fieldName ) {
+                if( object.isNull( fieldName ) )
+                        return "";
+                
+                // If the field is a object, return the 'name' property
+                def obj = object.optJSONObject( fieldName ) 
+                if( obj )
+                        return obj.optString( "name" )
+                else
+                        return object.optString( fieldName );
+        }
+        
+        protected handleSpecificFields( def inputFields ) {
+                def fields = [
+                        "names": [ 
+                                "all": [] 
+                        ],
+                        "descriptions": [
+                                "all": []
+                        ]
+                ]
+                
+                inputFields.each { key, value ->
+                        def names = [];
+                        def descriptions = []
+                        switch( key ) { 
+                                case "gscf":
+                                        value.each {
+                                                if( it != "sampleToken" && it != "name" ) {
+                                                        names << it;
+                                                        if( it == "startTime" )
+                                                                descriptions << "Event start time";
+                                                        else
+                                                                descriptions << it
+                                                }
+                                        }
+                                        break;
+                                case "subject":
+                                        value.each {
+                                                if( it != "name" ) {
+                                                        names << it;
+                                                        descriptions << it
+                                                }
+                                        }
+                                        break;
+                                case "event":
+                                        value.each {
+                                                if( it != "startTime" ) {
+                                                        names << it;
+                                                        descriptions << it
+                                                }
+                                        }
+                                        break;
+                                default:
+                                        names = value; descriptions = value;
+                                        break;
+                        }
+                        
+                        fields[ "names" ][ key ] = names;
+                        fields[ "names" ][ "all" ] += names;
+                        fields[ "descriptions" ][ key ] = descriptions;
+                        fields[ "descriptions" ][ "all" ] += descriptions;
+                }       
+                
+                return fields;
+
+        }
+        
 }

trunk/grails-app/services/nl/tno/metagenomics/files/FileService.groovy

@@ -100 +100 @@
 
                 if( !uploadDir )
-                uploadDir = "fileuploads"
+                        uploadDir = "fileuploads"
 
                 return absolutePath( uploadDir );

trunk/grails-app/services/nl/tno/metagenomics/integration/GscfService.groovy

@@ -12 +12 @@
  */
 class GscfService {
-
         def config = ConfigurationHolder.config
 
         static transactional = true
-
-
 
         /**
@@ -51 +48 @@
                 return "${config.gscf.baseURL}/study/showByToken/" + studyToken
         }
-        
-        /**
-        * Returns the url to add a new study in GSCF
-        *
-        * @return                       URL to redirect the user to
-        */
-   public String urlAddStudy( String studyToken ) {
-           return config.gscf.baseURL + config.gscf.addStudyPath
-   }
-
-   /**
-   * Retrieves the currently logged in user from GSCF
-   *
-   * @param sessionToken String
-   *
-   * @return Map
-   */
-  public Map getUser(String sessionToken) {
-          def user = [:]
-          this.callGSCF(sessionToken, "getUser").each {
-                  user[ it.key ] = it.value;
-          }
-          return user
-  }
-   
+
+        /**
+         * Returns the url to add a new study in GSCF
+         *
+         * @return                      URL to redirect the user to
+         */
+        public String urlAddStudy( String studyToken ) {
+                return config.gscf.baseURL + config.gscf.addStudyPath
+        }
+
+        /**
+         * Retrieves the currently logged in user from GSCF
+         *
+         * @param sessionToken String
+         *
+         * @return Map
+         */
+        public Map getUser(String sessionToken) {
+                def user = [:]
+                this.callGSCF(sessionToken, "getUser").each {
+                        user[ it.key ] = it.value;
+                }
+                return user
+        }
+
         /**
          * Retrieve a list of Studies from the GSCF
@@ -87 +84 @@
         }
 
-        
+
         /**
          * Retrieve a list of Studies from the GSCF
@@ -116 +113 @@
                 } catch( ResourceNotFoundException e ) {
                         throw new ResourceNotFoundException( "Study with token " + studyToken + " not found in GSCF" )
-                        throw e // Other exceptions are thrown as they appear
-                }
+                } // Other exceptions are thrown as they appear
 
                 // Return only the first element of the list, since we are only interested in one study
-                if( list.size() == 0 ) {
+                if( list?.size() ) {
+                        return list[0];
+                } else {
                         return []
-                } else {
-                        return list[0];
                 }
         }
@@ -172 +168 @@
         }
 
-        /** 
-         * Retrieve a list of Samples from the GSCF
-         * 
-         * @param sessionToken String
-         * @param assay Assay (parameter assay is optional, only used when you want to limit the list of samples of an Assay within a Study)
-         * 
-         * @return ArrayList 
-         */
-        public ArrayList getSamples(String sessionToken, String assayToken) throws NotAuthorizedException, ResourceNotFoundException {
-                // Samples of a Study limited to a single Assay
-                try {
-                        return this.callGSCF(sessionToken, "getSamples", ["assayToken":assayToken])
-                } catch( NotAuthorizedException e ) {
-                        throw new NotAuthorizedException( "User is not authorized to access study for assay with token " + assayToken )
-                } catch( ResourceNotFoundException e ) {1
-                        throw new ResourceNotFoundException( "Assay with token " + assayToken + " not found in GSCF" )
-                } // Other exceptions are thrown as they appear
-
-        }
-
+        
         /**
          * Retrieve a single Sample from the GSCF
-         * 
+         *
          * @param sessionToken String
          * @param assay Assay
-         * @param sample Sample  
-         * 
-         * @return ArrayList 
+         * @param sample Sample
+         *
+         * @return ArrayList
          */
         public def getSample(String sessionToken, String assayToken, String sampleToken) throws NotAuthorizedException, ResourceNotFoundException {
@@ -219 +196 @@
 
         }
+        
+        /** 
+         * Retrieve a list of Samples from the GSCF
+         * 
+         * @param sessionToken String
+         * @param assay Assay (parameter assay is optional, only used when you want to limit the list of samples of an Assay within a Study)
+         * 
+         * @return ArrayList 
+         */
+        public ArrayList getSamples(String sessionToken, String assayToken) throws NotAuthorizedException, ResourceNotFoundException {
+                // Samples of a Study limited to a single Assay
+                try {
+                        return this.callGSCF(sessionToken, "getSamples", ["assayToken":assayToken])
+                } catch( NotAuthorizedException e ) {
+                        throw new NotAuthorizedException( "User is not authorized to access study for assay with token " + assayToken )
+                } catch( ResourceNotFoundException e ) {1
+                        throw new ResourceNotFoundException( "Assay with token " + assayToken + " not found in GSCF" )
+                } // Other exceptions are thrown as they appear
+
+        }
+
+        /**
+         * Retrieve a list of samples from the GSCF
+         *
+         * @param sessionToken String
+         * @param sampleTokens List of sampleTokens
+         *
+         * @return ArrayList
+         */
+        public def getSamples(String sessionToken, List sampleTokens) throws NotAuthorizedException, ResourceNotFoundException {
+                def list
+
+                try {
+                        list = this.callGSCF(sessionToken, "getSamples", ["sampleToken": sampleTokens])
+                } catch( NotAuthorizedException e ) {
+                        throw new NotAuthorizedException( "User is not authorized to access samples" )
+                } catch( ResourceNotFoundException e ) {
+                        throw new ResourceNotFoundException( "Samples with token " + sampleTokens + " not found in GSCF" )
+                } // Other exceptions are thrown as they appear
+
+                // Return only the first element of the list, since we are only interested in one sample
+                return list
+        }
+
 
         /**
@@ -273 +294 @@
 
                 // concat all Rest Call specific arguments behind addr
-                restParams.each {parameter -> 
+                restParams.each {parameter ->
                         // If a list is given as value, the parameter should show up multiple times
                         if( parameter.value instanceof Collection ) {
@@ -281 +302 @@
                         } else {
                                 addr += "&${parameter.key}=" + parameter.value.toString().encodeAsURL()
-                        } 
+                        }
                 }
 

trunk/grails-app/services/nl/tno/metagenomics/integration/SynchronizationService.groovy

@@ -261 +261 @@
                         // Can't retrieve data. Maybe sessionToken has expired or invalid. Anyway, stop
                         // synchronizing and return null
+                        e.printStackTrace()
                         log.error( "Exception occurred when fetching study " + study.studyToken + ": " + e.getMessage() )
                         throw new Exception( "Error while fetching study " + study.studyToken, e)