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

Timestamp:

Jan 26, 2011, 5:08:25 PM (12 years ago)

Author:

robert@…

Message:

• Created tests for the synchronization and trash
• Improved synchronizationservice and trash
• Put authorization checks in several pages

Location:

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

Files:

• SampleExcelService.groovy (added)
• files/ExcelService.groovy (modified) (3 diffs)
• integration/SynchronizationService.groovy (modified) (12 diffs)
• integration/TrashService.groovy (modified) (14 diffs)

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

@@ -1 +1 @@
 package nl.tno.metagenomics.files
 
+import java.text.DecimalFormat
+import java.text.Format
+import java.text.NumberFormat
 import org.apache.poi.hssf.usermodel.*
 import org.apache.poi.ss.usermodel.*
@@ -71 +74 @@
                 // Now loop through all rows, retrieving data from the excel file
                 def df = new DataFormatter()
+                DecimalFormat numberformat =  new DecimalFormat( "0" );
+                
                 ArrayList data = []
                 
@@ -78 +83 @@
                         
                         for( def colNum = 0; colNum < excelRow.getLastCellNum(); colNum++ ) {
-                                row << df.formatCellValue( excelRow.getCell( colNum ) );
+                                Cell c = excelRow.getCell( colNum );
+                                if( c ) {
+                                        if( c.getCellType() == Cell.CELL_TYPE_NUMERIC ) {
+                                                row << numberformat.format( c.getNumericCellValue() );
+                                        } else {
+                                                row << df.formatCellValue( c );
+                                        }
+                                } else {
+                                        row << ""
+                                }
+                                
                         }
                         

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

@@ -96 +96 @@
         public ArrayList<Study> synchronizeStudies() {
                 if( !performSynchronization() )
-                        return Study.list()
+                        return Study.findAllWhereTrashcan(false)
 
                 // When eager fetching is enabled, ask for all studies, otherwise only ask for studies marked dirty
@@ -106 +106 @@
                         log.trace "Eager synchronization";
                 } else {
-                        studies = Study.findAllWhere( [isDirty: true] );
+                        studies = Study.findAllWhere( [trashcan: false, isDirty: true] );
                         log.trace "Default synchronization: " + studies.size()
 
@@ -184 +184 @@
                                         // Synchronize authorization and study assays (since the study itself is already synchronized)
                                         synchronizeAuthorization(studyFound);
-                                        synchronizeStudyAssays(studyFound);
+                                        if( studyFound.canRead( user ) )
+                                                synchronizeStudyAssays(studyFound);
 
                                         // Mark the study as clean
@@ -204 +205 @@
                 // should be deleted from this module as well. Looping backwards in order to avoid conflicts
                 // when removing elements from the list
+                
+                println "Handle deleted studies: " + studies.size() + " -> " + newStudies.size();
                 def numStudies = studies.size();
                 for( int i = numStudies - 1; i >= 0; i-- ) {
@@ -300 +303 @@
                 study.isDirty = true;
                 synchronizeAuthorization( study );
-                synchronizeStudyAssays( study );
+                if( study.canRead( user ) )
+                        synchronizeStudyAssays( study );
 
                 // Update properties and mark as clean
                 study.name = newStudy.title
                 study.isDirty = false;
-                study.save()
+                study.save(flush:true)
 
                 return study
@@ -466 +470 @@
 
                 // Copy properties from gscf object
-                a.canRead = gscfAuthorization.canRead
-                a.canWrite = gscfAuthorization.canWrite
-                a.isOwner = gscfAuthorization.isOwner
+                println "GSCF auth: " + gscfAuthorization
+                
+                if( gscfAuthorization.canRead instanceof Boolean  )
+                        a.canRead = gscfAuthorization.canRead.booleanValue()
+                
+                if( gscfAuthorization.canWrite instanceof Boolean )
+                        a.canWrite = gscfAuthorization.canWrite.booleanValue()
+                
+                if( gscfAuthorization.isOwner instanceof Boolean )
+                        a.isOwner = gscfAuthorization.isOwner.booleanValue()
+                        
+                println "Saved auth: " + a.canRead.toString() + " - " + a.canWrite.toString() + " - " + a.isOwner.toString()
 
                 a.save()
@@ -606 +619 @@
                 // already exist in the list of samples
                 newSamples.each { gscfSample ->
-                        log.trace( "Processing GSCF sample " + gscfSample.name + ": " + gscfSample )
+                        log.trace( "Processing GSCF sample " + gscfSample.sampleToken + ": " + gscfSample )
                         if( gscfSample.name ) {
 
-                                AssaySample assaySampleFound = assay.assaySamples.find { it.sample.sampleToken == gscfSample.name }
+                                AssaySample assaySampleFound = assay.assaySamples.find { it.sample.sampleToken == gscfSample.sampleToken }
                                 Sample sampleFound
 
                                 if(assaySampleFound) {
                                         sampleFound = assaySampleFound.sample
-                                        log.trace( "AssaySample found with sample " + sampleFound.name )
+                                        log.trace( "AssaySample found with sample name " + sampleFound.name )
 
                                         // Update the sample object if necessary
@@ -625 +638 @@
 
                                         // Check if the sample already exists in the database.
-                                        sampleFound = Sample.findBySampleTokenAndStudy( gscfSample.name as String, assay.study )
+                                        sampleFound = Sample.findBySampleTokenAndStudy( gscfSample.sampleToken as String, assay.study )
 
                                         if( sampleFound ){
-                                                log.trace( "Sample " + gscfSample.name + " is found in database. Updating if necessary" )
+                                                log.trace( "Sample " + gscfSample.sampleToken + " is found in database. Updating if necessary" )
 
                                                 // Update the sample object if necessary
                                                 if( sampleFound.name != gscfSample.name ) {
-                                                        sampleFound.name =gscfSample.name
+                                                        sampleFound.name = gscfSample.name
                                                         sampleFound.save();
                                                 }
                                         } else {
-                                                log.trace( "Sample " + gscfSample.name + " not found in database. Creating a new object." )
+                                                log.trace( "Sample " + gscfSample.sampleToken + " not found in database. Creating a new object." )
 
                                                 // If it doesn't exist, create a new object
-                                                sampleFound = new Sample( sampleToken: gscfSample.name, name: gscfSample.name, study: assay.study );
+                                                sampleFound = new Sample( sampleToken: gscfSample.sampleToken, name: gscfSample.name, study: assay.study );
+                                                assay.study.addToSamples( sampleFound );
                                                 sampleFound.save();
                                         }
@@ -649 +663 @@
                                         assay.addToAssaySamples( assaySampleFound );
                                         sampleFound.addToAssaySamples( assaySampleFound );
-                                        assaySampleFound.save();
+
+                                        assaySampleFound.save()
                                 }
                         }
@@ -670 +685 @@
                                 def existingSample = assaySamples[i];
 
-                                AssaySample sampleFound = newSamples.find { it.name == existingSample.sample.sampleToken }
+                                AssaySample sampleFound = newSamples.find { it.sampleToken == existingSample.sample.sampleToken }
 
                                 if( !sampleFound ) {
@@ -676 +691 @@
 
                                         // The sample has been removed
-                                        trashService.moveToTrash( existingSample.sample );
+                                        trashService.moveToTrash( existingSample );
                                 }
                         }
@@ -682 +697 @@
 
                 // Create a list of samples to return
-                return assay.assaySamples.toList()
-
+                if( assay.assaySamples )
+                        return assay.assaySamples.toList()
+                else
+                        return []
         }
 }

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

@@ -2 +2 @@
 
 import nl.tno.metagenomics.*
-
 
 class TrashService {
@@ -16 +15 @@
                 if( study.trashcan )
                         return
-                        
+
                 saveDataInTrash( study );
+                
+                def l = []
+                l += study.auth
+                
+                l.each { auth ->
+                        auth.user.removeFromAuth( auth );
+                        study.removeFromAuth( auth );
+                }
+                
                 study.delete(flush:true);
         }
-        
+
         /**
          * Moves the valuable data from an assay to trash and deletes the assay
@@ -27 +35 @@
         def moveToTrash( Assay assay ) {
                 saveDataInTrash( assay );
-                
+
                 // Remove associations
+                def l = []
+                if( assay.runs ) {
+                        l += assay.runs
+                        
+                        l.each {
+                                if( it ) {
+                                        assay.removeFromRuns( it );
+                                        it.removeFromAssays( assay );
+                                }
+                        }
+                }
+                
+                l = []
+                l += assay.assaySamples
+                
+                l.each {
+                        it.sample.removeFromAssaySamples( it );
+                        assay.removeFromAssaySamples( it );
+                }
+
+                def study = assay.study
+                if( study ) {
+                        study.removeFromAssays( assay );
+                }
+                
+                /*
+                def assaySamples = assay.assaySamples.toList();
+                assaySamples.each {
+                        it.assay = null
+
+                        assay.removeFromAssaySamples( it );
+                        it.sample.removeFromAssaySamples( it );
+                        it.sample = null;
+                        it.delete( flush: true );
+                }
+
                 assay.study.removeFromAssays( assay );
-                assay.delete(flush:true);
-        }
-        
+                assay.study.save();
+                //assay.study = null
+                //assay.delete(flush:true);
+                 */
+        }
+
         /**
          * Moves the valuable data from a sample to trash and deletes the sample
@@ -39 +86 @@
         def moveToTrash( Sample sample ) {
                 saveDataInTrash( sample );
-                
+
                 // Remove associations
+                def l = []
+                l += sample.assaySamples
+                
+                l.each {
+                        it.assay.removeFromAssaySamples( it );
+                        sample.removeFromAssaySamples( it );
+                }
+                
+                def study = sample.study
                 sample.study.removeFromSamples( sample );
-                sample.delete(flush:true);
-        }
-
+                study.save();
+        }
+
+        /**
+        * Moves the valuable data from an assaySample to trash and deletes the assay
+        * @param                Assay to move to trash
+        */
+   def moveToTrash( AssaySample assaySample ) {
+           saveDataInTrash( assaySample );
+
+           // Remove associations
+           if( assaySample.run ) {
+                   assaySample.run.removeFromAssaySamples( assaySample );
+           }
+           
+           if( assaySample.assay ) {
+                   assaySample.assay.removeFromAssaySamples( assaySample );
+           }
+
+           if( assaySample.sample ) {
+                   assaySample.sample.removeFromAssaySamples( assaySample );
+           }
+           
+           def l = []
+           l += assaySample.sequenceData
+           
+           l.each {
+                   if( it ) {
+                                assaySample.removeFromSequenceData( it );
+                   }
+           }
+           
+   }
+        
         /**
          * Saves data from the study in the trash can (if any data exists)
@@ -51 +138 @@
          */
         def saveDataInTrash( Study study ) {
-                Study trashcan = Study.findByTrashcan(true);
+                Study trashcan = this.giveTrashcan()
 
                 if( !trashcan ) {
@@ -71 +158 @@
          */
         def saveDataInTrash( Assay assay ) {
-                Study trashcan = Study.findByTrashcan(true);
+                Study trashcan = this.giveTrashcan()
 
                 if( !trashcan ) {
@@ -91 +178 @@
                         assaySamples.each { assaySample ->
                                 Sample sample = assaySample.sample
-                                
+
                                 // Create dummy sample
                                 String newSampleToken = 'TrashSample ' + new Date().format( 'yyyyMMddHHmmssSSS') + ( Math.random() * 10000 );
@@ -118 +205 @@
          */
         def saveDataInTrash( Sample sample ) {
-                Study trashcan = Study.findByTrashcan(true);
+                Study trashcan = this.giveTrashcan()
 
                 if( !trashcan ) {
@@ -159 +246 @@
         }
 
+        
+        /**
+        * Saves data from the assay-sample in the trash can (if any data exists)
+        * @param study          Sample to save data from
+        * @return
+        */
+   def saveDataInTrash( AssaySample assaySample ) {
+           Study trashcan = this.giveTrashcan()
+
+           if( !trashcan ) {
+                   log.warn "No trashcan (study with trashcan property set to true) found in the database when deleting sample " + sample.name + ". Possibly valuable data is deleted forever."
+                   return;
+           }
+
+           // For every assay sample that contains data, save that data in the trashcan
+           if( assaySample.containsData() ) {
+                   // Create dummy sample
+                   String newSampleToken = 'TrashSample ' + new Date().format( 'yyyyMMddHHmmssSSS') + ( Math.random() * 10000 );
+                   Sample dummySample = new Sample( sampleToken: newSampleToken, name: assaySample.sample.name, study: trashcan );
+                   trashcan.addToSamples( dummySample );
+                   dummySample.save()
+
+                   Assay assay = assaySample.assay;
+
+                   // Create a dummy assay copy of the existing assay
+                   String newAssayToken = 'TrashAssay ' + new Date().format( 'yyyyMMddHHmmssSSS') + ( Math.random() * 10000 );
+
+                   Assay dummyAssay = new Assay( assayToken: newAssayToken, name: assay.name, study: trashcan );
+                   trashcan.addToAssays( dummyAssay );
+                   dummyAssay.save()
+
+                   // Create dummy assay sample
+                   AssaySample dummyAssaySample = new AssaySample( assay: dummyAssay, sample: dummySample );
+
+                   dummyAssay.addToAssaySamples( dummyAssaySample );
+                   dummySample.addToAssaySamples( dummyAssaySample );
+                   dummyAssaySample.save();
+
+                   // Move data from this assay sample to the trash version of it
+                   assaySample.moveValuableDataTo( dummyAssaySample );
+                   dummyAssaySample.save();
+           }
+   }
+
+        /**
+         * Retrieves the trashcan study from the database 
+         */
+        def giveTrashcan = {
+                def study = Study.findByTrashcan( true );
+
+                if( !study )
+                        return null;
+                else
+                        return study
+        }
+        
+        /**
+         * Creates a new trashcan study. Should only be used by the bootstrap to create a trashcan
+         */
+        def createTrashcan = {
+                def study = new Study( name: "Trashcan", studyToken: "trash", trashcan: true )
+                study.save();
+        }
+
         /**
          * Cleans up the trash by removing empty assays or samples. Empty means:
@@ -168 +319 @@
         def cleanTrash = {
                 def studies = Study.findAllByTrashcan( true );
-                
+
                 studies.each { study ->
                         def numAssays = study.assays?.size()
                         def assayList = study.assays?.toList();
-                        
+
                         def numSamples
                         def sampleList
-                        
+
                         // Loop backwards through the assays in order to facilitate removing assays
                         for( def i = numAssays -1; i >= 0; i-- ) {
@@ -182 +333 @@
                                         numSamples = assayList[ i ].assaySamples.size()
                                         sampleList = assayList[ i ].assaySamples.toList();
-                                        
+
                                         for( def j = numSamples - 1; j >= 0; j-- ) {
                                                 def s = sampleList[ j ];
@@ -197 +348 @@
                                         study.removeFromAssays( assayList[ i ] );
                                         assayList[i].delete();
-                                } 
-                        }
-                        
+                                }
+                        }
+
                         // Loop through samples and delete the ones not referenced by an assaysample
                         /*
-                        numSamples = study.samples?.size()
-                        sampleList = study.samples?.toList();
-                        
-                        for( def j = numSamples - 1; j >= 0; j-- ) {
-                                def s = sampleList[ j ];
-                                if( s.assaySamples == null || s.assaySamples.size() == 0 ) {
-                                        study.removeFromSamples(s);
-                                        s.delete(flush:true);
-                                }
-                        }
-                        */
-                }
-        }
-        
+                         numSamples = study.samples?.size()
+                         sampleList = study.samples?.toList();
+                         for( def j = numSamples - 1; j >= 0; j-- ) {
+                         def s = sampleList[ j ];
+                         if( s.assaySamples == null || s.assaySamples.size() == 0 ) {
+                         study.removeFromSamples(s);
+                         s.delete(flush:true);
+                         }
+                         }
+                         */
+                }
+        }
+
         /**
          * Restore an assay from trash and put the contents of the assay in another assay
@@ -227 +377 @@
                                 // Find a sample with the same name
                                 def restoreSample = restoreTo.assaySamples.find { it.sample?.name == assaySample.sample?.name }
-                                
+
                                 if( restoreSample ) {
                                         this.restoreSample( assaySample, restoreSample );
@@ -234 +384 @@
                 }
         }
-        
+
         /**
          * Restore a sample from trash and put the contents of the sample into another sample