source: trunk/grails-app/services/nl/tno/metagenomics/integration/SynchronizationService.groovy @ 9

Last change on this file since 9 was 9, checked in by robert@…, 9 years ago
File size: 23.8 KB
Line 
1package nl.tno.metagenomics.integration
2
3import nl.tno.metagenomics.*
4import nl.tno.metagenomics.auth.*
5import org.codehaus.groovy.grails.commons.ConfigurationHolder
6
7class SynchronizationService {
8        def gscfService
9        def trashService
10
11        String sessionToken = ""        // Session token to use for communication
12        User user = null                        // Currently logged in user. Must be set when synchronizing authorization
13        boolean eager = false           // When set to true, this method fetches data about all studies from GSCF. Otherwise, it will only look at the
14        // studies marked as dirty in the database. Defaults to false.
15
16        // Keeps track of the last time this module performed a full synchronization.
17        static Date lastFullSynchronization = null;
18
19        static transactional = true
20
21        /**
22         * Determines whether the synchronization should be performed or not. This can be entered
23         * in configuration, to avoid synchronization when developing.
24         * @return
25         */
26        protected performSynchronization() {
27                def conf = ConfigurationHolder.config.metagenomics.synchronization;
28
29                // If nothing is entered in configuration, return true (default value)
30                if( conf == null )
31                        return true
32
33                return conf
34        }
35       
36        /**
37         * Returns true iff a full synchronization should be performed
38         * @return
39         */
40        public boolean timeForFullSynchronization() {
41                if( SynchronizationService.lastFullSynchronization == null )
42                        return true
43                       
44                // Compute the time since the last full synchronization in  milliseconds
45                Date today = new Date();
46                long difference = SynchronizationService.lastFullSynchronization.getTime() - today.getTime()
47               
48                if( difference / 1000 > ConfigurationHolder.config.metagenomics.fullSynchronization )
49                        return true
50                else
51                        return false
52        }
53
54        /**
55         * Redirects to a temporary page to give the user a 'waiting' page while synchronizing
56         * @return
57         */
58        public String urlForFullSynchronization( def params ) {
59                def returnUrl = ConfigurationHolder.config.grails.serverURL
60                if (params.controller != null){
61                        returnUrl += "/${params.controller}"
62                        if (params.action != null){
63                                returnUrl += "/${params.action}"
64                                if (params.id != null){
65                                        returnUrl += "/${params.id}"
66                                }
67                        }
68                }
69                if( timeForFullSynchronization() ) {
70                        return ConfigurationHolder.config.grails.serverURL + "/synchronize/full?redirect=" + returnUrl.encodeAsURL()
71                } else {
72                        return returnUrl
73                }
74        }
75
76        /**
77         * Performs a full synchronization in order to retrieve all studies
78         * @return
79         */
80        public void fullSynchronization() {
81                def previousEager = this.eager
82                this.eager = true
83                this.synchronizeStudies();
84                this.eager = previousEager
85               
86                SynchronizationService.lastFullSynchronization = new Date();
87        }
88
89        /**
90         * Synchronizes all studies with the data from GSCF.
91         * @return      ArrayList       List of studies or null if the synchronization has failed
92         */
93        public ArrayList<Study> synchronizeStudies() {
94                if( !performSynchronization() )
95                        return Study.findAllWhereTrashcan(false)
96
97                // When eager fetching is enabled, ask for all studies, otherwise only ask for studies marked dirty
98                // Synchronization is performed on all studies, not only the studies the user has access to. Otherwise
99                // we would never notice that a user was given read-access to a study.
100                def studies
101                if( eager ) {
102                        studies = []
103                        log.trace "Eager synchronization";
104                } else {
105                        studies = Study.findAllWhere( [trashcan: false, isDirty: true] );
106                        log.trace "Default synchronization: " + studies.size()
107
108                        // Perform no synchronization if no studies have to be synchronized
109                        if( studies.size() == 0 )
110                                return []
111                }
112               
113                // Perform synchronization on only one study directly, because otherwise
114                // the getStudies method could throw a ResourceNotFoundException or NotAuthorizedException
115                // that can better be handled by synchronizeStudy
116                if( studies.size() == 1 ) {
117                        def newStudy = synchronizeStudy( studies[0] );
118                        if( newStudy )
119                                return [ newStudy ];
120                        else
121                                return []
122                }
123
124                // Fetch all studies from GSCF
125                def newStudies
126                try {
127                        if( !eager ) {
128                                def studyTokens = studies.studyToken;
129
130                                if( studyTokens instanceof String ) {
131                                        studyTokens = [studyTokens];
132                                }
133                                println "Only updating studies with tokens " + studyTokens.join( ',' );
134                                newStudies = gscfService.getStudies(sessionToken, studyTokens)
135                        } else {
136                                newStudies = gscfService.getStudies(sessionToken)
137                        }
138                } catch( Exception e ) { // All exceptions are thrown.
139                        // Can't retrieve data. Maybe sessionToken has expired or invalid. Anyway, stop
140                        // synchronizing and return null
141                        log.error( "Exception occurred when fetching studies: " + e.getMessage() )
142                        throw new Exception( "Error while fetching studies", e)
143                }
144
145                synchronizeStudies( newStudies );
146                studies = handleDeletedStudies( studies, newStudies );
147
148                log.trace( "Returning " + studies.size() + " studies after synchronization" )
149
150                return studies
151        }
152
153        /**
154         * Synchronizes all studies given by 'newStudies' with existing studies in the database, and adds them
155         * if they don't exist
156         *
157         * @param newStudies            JSON object with studies as returned by GSCF
158         * @return
159         */
160        protected synchronizeStudies( def newStudies ) {
161                // Synchronize all studies that are returned. Studies that are not returned by GSCF might be removed
162                // but could also be invisible for the current user.
163                newStudies.each { gscfStudy ->
164                        if( gscfStudy.studyToken ) {
165                                log.trace( "Processing GSCF study " + gscfStudy.studyToken + ": " + gscfStudy )
166
167                                Study studyFound = Study.findByStudyToken( gscfStudy.studyToken as String )
168
169                                if(studyFound) {
170                                        log.trace( "Study found with name " + studyFound.name )
171
172                                        // Synchronize the study itself with the data retrieved
173                                        synchronizeStudy( studyFound, gscfStudy );
174                                } else {
175                                        log.trace( "Study not found. Creating a new one" )
176
177                                        // If it doesn't exist, create a new object
178                                        studyFound = new Study( studyToken: gscfStudy.studyToken, name: gscfStudy.title, isDirty: true );
179                                        studyFound.save();
180
181                                        // Synchronize authorization and study assays (since the study itself is already synchronized)
182                                        synchronizeAuthorization(studyFound);
183                                        if( studyFound.canRead( user ) )
184                                                synchronizeStudyAssays(studyFound);
185
186                                        // Mark the study as clean
187                                        studyFound.isDirty = false
188                                        studyFound.save();
189                                }
190                        }
191                }
192        }
193
194        /**
195         * Removes studies from the database that are expected but not found in the list from GSCF
196         * @param studies               List with existing studies in the database that were expected in the output of GSCF
197         * @param newStudies    JSON object with studies as returned by GSCF
198         * @return                              List of remaining studies
199         */
200        protected ArrayList<Study> handleDeletedStudies( def studies, def newStudies ) {
201                // If might also be that studies have been removed from the system. In that case, the studies
202                // should be deleted from this module as well. Looping backwards in order to avoid conflicts
203                // when removing elements from the list
204               
205                println "Handle deleted studies: " + studies.size() + " -> " + newStudies.size();
206                def numStudies = studies.size();
207                for( int i = numStudies - 1; i >= 0; i-- ) {
208                        def existingStudy = studies[i];
209
210                        def studyFound = newStudies.find { it.studyToken == existingStudy.studyToken }
211
212                        if( !studyFound ) {
213                                log.trace( "Study " + existingStudy.studyToken + " not found. Check whether it is removed or the user just can't see it." )
214
215                                // Study was not given to us by GSCF. This might be because the study is removed, or because the study is not visible (anymore)
216                                // to the current user.
217                                // Synchronize authorization and see what is the case (it returns null if the study has been deleted)
218                                if( synchronizeAuthorization( existingStudy ) == null ) {
219                                        // Update studies variable to keep track of all existing studies
220                                        studies.remove( existingStudy )
221                                }
222                        }
223                }
224
225                return studies
226        }
227
228        /**
229         * Synchronizes the given study with the data from GSCF
230         * @param       study   Study to synchronize
231         * @return      Study   Synchronized study or null if the synchronization has failed
232         */
233        public Study synchronizeStudy(Study study ) {
234                if( !performSynchronization() )
235                        return study
236
237                if( study == null )
238                        return null
239
240                // Trashcan should never be synchronized
241                if( study.trashcan )
242                        return study
243                       
244                // If the study hasn't changed, don't update anything
245                if( !eager && !study.isDirty )
246                        return study;
247
248                // Retrieve the study from GSCF
249                def newStudy
250                try {
251                        newStudy = gscfService.getStudy(sessionToken, study.studyToken)
252                } catch( NotAuthorizedException e ) {
253                        // User is not authorized to access this study. Update the authorization within the module and return
254                        synchronizeAuthorization( study );
255                        return null
256                } catch( ResourceNotFoundException e ) {
257                        // Study can't be found within GSCF.
258                        trashService.moveToTrash( study );
259                        return null
260                } catch( Exception e ) { // All other exceptions
261                        // Can't retrieve data. Maybe sessionToken has expired or invalid. Anyway, stop
262                        // synchronizing and return null
263                        log.error( "Exception occurred when fetching study " + study.studyToken + ": " + e.getMessage() )
264                        throw new Exception( "Error while fetching study " + study.studyToken, e)
265                }
266
267                // If no study is returned, something went wrong.
268                if( newStudy.size() == 0 ) {
269                        throw new Exception( "No data returned for study " + study.studyToken + " but no error has occurred either. Please contact your system administrator" );
270                        return null;
271                }
272
273                return synchronizeStudy(study, newStudy);
274        }
275
276        /**
277         * Synchronizes the given study with the data from GSCF
278         * @param       study           Study to synchronize
279         * @param       newStudy        Data to synchronize the study with
280         * @return      Study           Synchronized study or null if the synchronization has failed
281         */
282        protected Study synchronizeStudy(Study study, def newStudy) {
283                if( !performSynchronization() )
284                        return study
285
286                if( study == null || newStudy == null)
287                        return null
288
289                // If the study hasn't changed, don't update anything
290                if( !eager && !study.isDirty ) {
291                        return study;
292                }
293
294                // If no study is returned, something went wrong.
295                if( newStudy.size() == 0 ) {
296                        return null;
297                }
298
299                // Mark study dirty to enable synchronization
300                study.isDirty = true;
301                synchronizeAuthorization( study );
302                if( study.canRead( user ) )
303                        synchronizeStudyAssays( study );
304
305                // Update properties and mark as clean
306                study.name = newStudy.title
307                study.isDirty = false;
308                study.save(flush:true)
309
310                return study
311        }
312
313        /**
314         * Synchronizes the assays of the given study with the data from GSCF
315         * @param study         Study of which the assays should be synchronized
316         * @return      ArrayList       List of assays or null if the synchronization has failed
317         */
318        protected ArrayList<Assay> synchronizeStudyAssays( Study study ) {
319                if( !performSynchronization() )
320                        return study.assays.toList()
321
322                if( !eager && !study.isDirty )
323                        return study.assays as List
324
325                // Also update all assays, belonging to this study
326                // Retrieve the assays from GSCF
327                def newAssays
328                try {
329                        newAssays = gscfService.getAssays(sessionToken, study.studyToken)
330                } catch( Exception e ) { // All exceptions are thrown. If we get a NotAuthorized or NotFound Exception, something has changed in between the two requests. This will result in an error
331                        // Can't retrieve data. Maybe sessionToken has expired or invalid. Anyway, stop
332                        // synchronizing and return null
333                        log.error( "Exception occurred when fetching assays for study " + study.studyToken + ": " + e.getMessage() )
334                        throw new Exception( "Error while fetching samples for assay " + study.studyToken, e)
335                }
336
337                // If no assay is returned, we remove all assays
338                // from this study and return an empty list
339                if( newAssays.size() == 0 && study.assays != null ) {
340                        def studyAssays = study.assays.toArray();
341                        def numStudyAssays = study.assays.size();
342                        for( int i = numStudyAssays - 1; i >= 0; i-- ) {
343                                def existingAssay = studyAssays[i];
344                               
345                                // Move data to trash
346                                trashService.moveToTrash( existingAssay );
347                        }
348
349                        return []
350                }
351
352                synchronizeStudyAssays( study, newAssays );
353                return handleDeletedAssays( study, newAssays );
354        }
355
356        /**
357         * Synchronizes the assays of a study with the given data from GSCF
358         * @param study         Study to synchronize
359         * @param newAssays     JSON object given by GSCF to synchronize the assays with
360         */
361        protected void synchronizeStudyAssays( Study study, def newAssays ) {
362                // Otherwise, we search for all assays in the new list, if they
363                // already exist in the list of assays
364                newAssays.each { gscfAssay ->
365                        if( gscfAssay.assayToken ) {
366                                log.trace( "Processing GSCF assay " + gscfAssay.assayToken + ": " + gscfAssay )
367
368                                Assay assayFound = study.assays.find { it.assayToken == gscfAssay.assayToken }
369
370                                if(assayFound) {
371                                        log.trace( "Assay found with name " + assayFound.name )
372
373                                        // Synchronize the assay itself with the data retrieved
374                                        synchronizeAssay( assayFound, gscfAssay );
375                                } else {
376                                        log.trace( "Assay not found in study. Creating a new one" )
377
378                                        // If it doesn't exist, create a new object
379                                        assayFound = new Assay( assayToken: gscfAssay.assayToken, name: gscfAssay.name, study: study );
380
381                                        log.trace( "Connecting assay to study" )
382                                        study.addToAssays( assayFound );
383                                        assayFound.save()
384
385                                        // Synchronize assay samples (since the assay itself is already synchronized)
386                                        synchronizeAssaySamples(assayFound)
387                                }
388                        }
389                }
390        }
391
392        /**
393         * Removes assays from the system that have been deleted from GSCF
394         * @param study         Study to synchronize
395         * @param newAssays     JSON object given by GSCF to synchronize the assays with
396         * @return      List with all assays from the study
397         */
398        protected ArrayList<Assay> handleDeletedAssays( Study study, def newAssays ) {
399                if( study.assays == null ) {
400                        return []
401                }
402
403                // If might also be that assays have been removed from this study. In that case, the removed assays
404                // should be deleted from this study in the module as well. Looping backwards in order to avoid conflicts
405                // when removing elements from the list
406                def assays = study.assays.toArray();
407                def numAssays = assays.size();
408                for( int i = numAssays - 1; i >= 0; i-- ) {
409                        def existingAssay = assays[i];
410
411                        Assay assayFound = newAssays.find { it.assayToken == existingAssay.assayToken }
412
413                        if( !assayFound ) {
414                                log.trace( "Assay " + existingAssay.assayToken + " not found. Removing it." )
415
416                                // The assay has been removed
417                                trashService.moveToTrash( existingAssay );
418                        }
419                }
420
421                return study.assays.toList()
422        }
423
424        /**
425         * Retrieves the authorization for the currently logged in user
426         * Since GSCF only provides authorization information about the currently
427         * logged in user, we can not guarantee that the authorization information
428         * is synchronized for all users.
429         *
430         * Make sure synchronizationService.user is set beforehand
431         * 
432         * @param study Study to synchronize authorization for
433         * @return      Auth object for the given study and user
434         */
435        public Auth synchronizeAuthorization(Study study) {
436                // If the user is not set, we can't save anything to the database.
437                if( user == null ) {
438                        throw new Exception( "Property user of SynchronizationService must be set to the currently logged in user" );
439                }
440
441                // Only perform synchronization if needed
442                if( !eager && !study.isDirty )
443                        return Auth.findByUserAndStudy( user, study )
444
445                if( !performSynchronization() )
446                        return Auth.findByUserAndStudy( user, study )
447
448                def gscfAuthorization
449                try {
450                        gscfAuthorization = gscfService.getAuthorizationLevel( sessionToken, study.studyToken )
451                } catch( ResourceNotFoundException e ) {
452                        // Study has been deleted, remove all authorization on that study
453                        log.trace( "Study " + study.studyToken + " has been deleted. Remove all authorization on that study")
454                        trashService.moveToTrash( study );
455
456                        return null
457                }
458
459                // Update the authorization object, or create a new one
460                Auth a = Auth.authorization( study, user )
461
462                if( !a ) {
463                        log.trace( "Authorization not found for " + study.studyToken + " and " + user.username + ". Creating a new object" );
464
465                        a = Auth.createAuth( study, user );
466                }
467
468                // Copy properties from gscf object
469                println "GSCF auth: " + gscfAuthorization
470               
471                if( gscfAuthorization.canRead instanceof Boolean  )
472                        a.canRead = gscfAuthorization.canRead.booleanValue()
473               
474                if( gscfAuthorization.canWrite instanceof Boolean )
475                        a.canWrite = gscfAuthorization.canWrite.booleanValue()
476               
477                if( gscfAuthorization.isOwner instanceof Boolean )
478                        a.isOwner = gscfAuthorization.isOwner.booleanValue()
479                       
480                println "Saved auth: " + a.canRead.toString() + " - " + a.canWrite.toString() + " - " + a.isOwner.toString()
481
482                a.save()
483
484                return a
485        }
486
487        /**
488         * Synchronizes the given assay with the data from GSCF
489         * @param assay         Assay to synchronize
490         * @return      Assay   Synchronized assay or null if the synchronization has failed
491         */
492        public Assay synchronizeAssay(Assay assay) {
493                if( !performSynchronization() )
494                        return assay
495
496                if( assay == null )
497                        return null
498
499                // Only perform synchronization if needed
500                if( !eager && !assay.study.isDirty )
501                        return assay
502
503                // Retrieve the assay from GSCF
504                def newAssay
505                try {
506                        newAssay = gscfService.getAssay(sessionToken, assay.study.studyToken, assay.assayToken)
507                } catch( NotAuthorizedException e ) {
508                        // User is not authorized to access this study. Update the authorization within the module and return
509                        synchronizeAuthorization( assay.study );
510                        return null
511                } catch( ResourceNotFoundException e ) {
512                        // Assay can't be found within GSCF.
513                        trashService.moveToTrash( assay );
514                        return null
515                } catch( Exception e ) { // All other exceptions are thrown
516                        // Can't retrieve data. Maybe sessionToken has expired or invalid. Anyway, stop
517                        // synchronizing and return null
518                        log.error( "Exception occurred when fetching assay " + assay.assayToken + ": " + e.getMessage() )
519                        throw new Exception( "Error while fetching assay " + assay.assayToken, e)
520                }
521
522                // If new assay is empty, this means that the assay does exist, but now belongs to another module. Remove it from our system
523                if( newAssay.size() == 0 ) {
524                        log.info( "No data is returned by GSCF for assay  " + assay.assayToken + "; probably the assay is connected to another module." )
525                        trashService.moveToTrash( assay );
526                        return null;
527                }
528
529                return synchronizeAssay( assay, newAssay );
530        }
531
532        /**
533         * Synchronizes the given assay with the data given
534         * @param assay         Assay to synchronize
535         * @param newAssay      New data for the assay, retrieved from GSCF
536         * @return      Assay   Synchronized assay or null if the synchronization has failed
537         */
538        protected Assay synchronizeAssay(Assay assay, def newAssay) {
539                if( !performSynchronization() )
540                        return assay
541
542                if( assay == null || newAssay == null )
543                        return null
544
545                // Only perform synchronization if needed
546                if( !eager && !assay.study.isDirty )
547                        return assay
548
549                // If new assay is empty, something went wrong
550                if( newAssay.size() == 0 ) {
551                        return null;
552                }
553
554                log.trace( "Assay is found in GSCF: " + assay.name + " / " + newAssay )
555                if( newAssay?.name ) {
556                        assay.name = newAssay.name
557                        assay.save()
558                }
559
560                // Synchronize samples
561                synchronizeAssaySamples(assay);
562
563                return assay
564        }
565
566        /**
567         * Synchronizes the samples of a given assay with the data from GSCF
568         * @param       assay   Assay to synchronize
569         * @return      Sample  List of samples or null if the synchronization failed
570         */
571        protected ArrayList<AssaySample> synchronizeAssaySamples(Assay assay) {
572                if( !performSynchronization() )
573                        return assay.assaySamples.toList()
574
575                // If no assay is given, return null
576                if( assay == null )
577                        return null
578
579                // Retrieve the assay from GSCF
580                def newSamples
581                try {
582                        newSamples = gscfService.getSamples(sessionToken, assay.assayToken)
583                } catch( NotAuthorizedException e ) {
584                        // User is not authorized to access this study. Update the authorization within the module and return
585                        synchronizeAuthorization( assay.study );
586                        return null
587                } catch( ResourceNotFoundException e ) {
588                        // Assay can't be found within GSCF. Samples will be removed
589                        trashService.moveToTrash( assay );
590
591                        return null
592                } catch( Exception e ) {
593                        // Can't retrieve data. Maybe sessionToken has expired or invalid. Anyway, stop
594                        // synchronizing and return null
595                        log.error( "Exception occurred when fetching samples for assay " + assay.assayToken + ": " + e.getMessage() )
596                        throw new Exception( "Error while fetching samples for assay " + assay.assayToken, e)
597                }
598
599                // If no sample is returned, we remove all samples from the list
600                if( newSamples.size() == 0 ) {
601                        assay.removeAssaySamples();
602                        return []
603                }
604
605                synchronizeAssaySamples( assay, newSamples );
606                return handleDeletedSamples( assay, newSamples );
607        }
608
609        /**
610         * Synchronize all samples for a given assay with the data from GSCF
611         * @param assay                 Assay to synchronize samples for
612         * @param newSamples    New samples in JSON object, as given by GSCF
613         */
614        protected void synchronizeAssaySamples( Assay assay, def newSamples ) {
615                // Otherwise, we search for all samples in the new list, if they
616                // already exist in the list of samples
617                newSamples.each { gscfSample ->
618                        log.trace( "Processing GSCF sample " + gscfSample.sampleToken + ": " + gscfSample )
619                        if( gscfSample.name ) {
620
621                                AssaySample assaySampleFound = assay.assaySamples.find { it.sample.sampleToken == gscfSample.sampleToken }
622                                Sample sampleFound
623
624                                if(assaySampleFound) {
625                                        sampleFound = assaySampleFound.sample
626                                        log.trace( "AssaySample found with sample name " + sampleFound.name )
627
628                                        // Update the sample object if necessary
629                                        sampleFound.name = gscfSample.name
630                                        sampleFound.subject = gscfSample.subject
631                                        sampleFound.event = gscfSample.event + ( gscfSample.startTime ? " (" + gscfSample.startTime + ")" : "" )
632                                        sampleFound.save();
633                                } else {
634                                        log.trace( "AssaySample not found in assay" )
635
636                                        // Check if the sample already exists in the database.
637                                        sampleFound = Sample.findBySampleTokenAndStudy( gscfSample.sampleToken as String, assay.study )
638
639                                        if( sampleFound ){
640                                                log.trace( "Sample " + gscfSample.sampleToken + " is found in database. Updating if necessary" )
641
642                                                // Update the sample object if necessary
643                                                sampleFound.name = gscfSample.name
644                                                sampleFound.subject = gscfSample.subject
645                                                sampleFound.event = gscfSample.event + ( gscfSample.startTime ? " (" + gscfSample.startTime + ")" : "" )
646                                                sampleFound.save();
647                                        } else {
648                                                log.trace( "Sample " + gscfSample.sampleToken + " not found in database. Creating a new object." )
649
650                                                // If it doesn't exist, create a new object
651                                                sampleFound = new Sample( sampleToken: gscfSample.sampleToken, name: gscfSample.name, study: assay.study );
652                                                sampleFound.subject = gscfSample.subject
653                                                sampleFound.event = gscfSample.event + ( gscfSample.startTime ? " (" + gscfSample.startTime + ")" : "" )
654                                                assay.study.addToSamples( sampleFound );
655                                                sampleFound.save();
656                                        }
657
658                                        // Create a new assay-sample combination
659                                        log.trace( "Connecting sample to assay" )
660                                        assaySampleFound = new AssaySample();
661
662                                        assay.addToAssaySamples( assaySampleFound );
663                                        sampleFound.addToAssaySamples( assaySampleFound );
664
665                                        assaySampleFound.save()
666                                }
667                        }
668                }
669        }
670
671        /**
672         * Removes samples from the system that have been removed from an assay in GSCF
673         * @param assay                 Assay to remove samples for
674         * @param newSamples    JSON object with all samples for this assay as given by GSCF
675         */
676        protected ArrayList<AssaySample> handleDeletedSamples( Assay assay, def newSamples ) {
677                // If might also be that samples have been removed from this assay. In that case, the removed samples
678                // should be deleted from this assay. Looping backwards in order to avoid conflicts when removing elements
679                // from the list
680                if( assay.assaySamples != null ) {
681                        def assaySamples = assay.assaySamples.toArray();
682                        def numAssaySamples = assay.assaySamples.size();
683                        for( int i = numAssaySamples - 1; i >= 0; i-- ) {
684                                def existingSample = assaySamples[i];
685
686                                AssaySample sampleFound = newSamples.find { it.sampleToken == existingSample.sample.sampleToken }
687
688                                if( !sampleFound ) {
689                                        log.trace( "Sample " + existingSample.sample.sampleToken + " not found. Removing it." )
690
691                                        // The sample has been removed
692                                        trashService.moveToTrash( existingSample );
693                                }
694                        }
695                }
696
697                // Create a list of samples to return
698                if( assay.assaySamples )
699                        return assay.assaySamples.toList()
700                else
701                        return []
702        }
703}
Note: See TracBrowser for help on using the repository browser.