source: trunk/grails-app/services/nl/tno/metagenomics/integration/GscfService.groovy @ 2

package nl.tno.metagenomics.integration

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

/**
 * EDP (External Data Provider) for GSCF
 * 
 * @author Robert Horlings (robert@isdat.nl)
 * @version 0.9
 * @see nmcdsp.GscfService
 */
class GscfService {

        def config = ConfigurationHolder.config

        static transactional = true



        /**
         * Returns the URL to let the user login at GSCF
         *
         * @param params        Parameters of the action called
         * @param token         Session token
         * @return                      URL to redirect the user to
         */
        public String urlAuthRemote( def params, def token ) {
                def redirectURL = "${config.gscf.baseURL}/login/auth_remote?moduleURL=${this.moduleURL()}&consumer=${this.consumerID()}&token=${token}&returnUrl=${config.metagenomics.baseURL}"

                if (params.controller != null){
                        redirectURL += "/${params.controller}"
                        if (params.action != null){
                                redirectURL += "/${params.action}"
                                if (params.id != null){
                                        redirectURL += "/${params.id}"
                                }
                        }
                }

                return redirectURL
        }

        /**
         * Returns the url to show details of a study in GSCF
         *
         * @param study         Study object to view in GSCF
         * @return                      URL to redirect the user to
         */
        public String urlViewStudy( String studyToken ) {
                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
   }

        /**
         * Retrieve a list of Studies from the GSCF
         * 
         * @param sessionToken String
         * 
         * @return ArrayList 
         */
        public ArrayList getStudies(String sessionToken) {
                return this.callGSCF(sessionToken, "getStudies")
        }

        
        /**
         * Retrieve a list of Studies from the GSCF
         *
         * @param sessionToken String
         *
         * @return ArrayList
         */
        public ArrayList getStudies(String sessionToken, ArrayList studyTokens ) {
                return this.callGSCF(sessionToken, "getStudies", [ "studyToken": studyTokens ] );
        }

        /**
         * Retrieve a single Study from the GSCF
         * 
         * @param sessionToken String
         * @param study Study
         * 
         * @return ArrayList 
         */
        public def getStudy(String sessionToken, String studyToken) throws NotAuthorizedException, ResourceNotFoundException {
                def list

                try {
                        list = this.callGSCF(sessionToken, "getStudies", ["studyToken": studyToken])
                } catch( NotAuthorizedException e ) {
                        throw new NotAuthorizedException( "User is not authorized to access study with token " + studyToken )
                } catch( ResourceNotFoundException e ) {
                        throw new ResourceNotFoundException( "Study with token " + studyToken + " not found in GSCF" )
                        throw e // 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 ) {
                        return []
                } else {
                        return list[0];
                }
        }

        /**
         * Retrieve a list of Assays from the GSCF
         * 
         * @param sessionToken String
         * @param study Study 
         * 
         * @return ArrayList 
         */
        public ArrayList getAssays(String sessionToken, String studyToken) {
                try {
                        return this.callGSCF(sessionToken, "getAssays", ["studyToken": studyToken])
                } catch( NotAuthorizedException e ) {
                        throw new NotAuthorizedException( "User is not authorized to access study with token " + studyToken )
                } catch( ResourceNotFoundException e ) {
                        throw new ResourceNotFoundException( "Study with token " + studyToken + " not found in GSCF" )
                } // Other exceptions are thrown as they appear
        }

        /**
         * Retrieve a single Assay from the GSCF
         * 
         * @param sessionToken String
         * @param study Study
         * @param assay Assay 
         * 
         * @return ArrayList 
         */     
        public def getAssay(String sessionToken, String studyToken, String assayToken ) {
                def list
                try {
                        list = this.callGSCF(sessionToken, "getAssays", ["studyToken": studyToken, "assayToken": assayToken])
                } catch( NotAuthorizedException e ) {
                        throw new NotAuthorizedException( "User is not authorized to access study with token " + studyToken )
                } catch( ResourceNotFoundException e ) {
                        throw new ResourceNotFoundException( "Assay with token " + assayToken + " 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 assay
                if( list.size() == 0 ) {
                        return []
                } else {
                        return list[0];
                }
        }

        /** 
         * 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) {
                // 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 
         */
        public def getSample(String sessionToken, String assayToken, String sampleToken) {
                def list

                try {
                        list = this.callGSCF(sessionToken, "getSamples", ["assayToken": assayToken , "sampleToken": sampleToken])
                } 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

                // Return only the first element of the list, since we are only interested in one sample
                if( list.size() == 0 )
                        return []
                else
                        return list[ 0 ];

        }

        /**
         * Retrieve study access
         *
         * @param sessionToken String
         * @param study Study
         *
         * @return ArrayList
         */
        public HashMap getAuthorizationLevel(String sessionToken, String studyToken) {
                ArrayList list

                try {
                        list = this.callGSCF(sessionToken, "getAuthorizationLevel", ["studyToken":studyToken])
                } catch( ResourceNotFoundException e ) {
                        throw new ResourceNotFoundException( "Study with token " + studyToken + " not found in GSCF")
                } // Other exceptions are thrown as they appear

                HashMap map = [:]

                // Convert the list back to a hashmap
                list.each { entry ->
                        map[ entry.key ] = entry.value
                }

                return map
        }

        /**
         * Base URL of GSCF Rest Controller/API
         *
         * @return      url String
         */
        private String restURL() {
                return "${config.gscf.baseURL}/rest"
        }

        /**
         * Call GSCF Service via a secure call
         *
         * @param       sessionToken Session token for connection to GSCF
         * @param       restMethod Method to call on GSCF rest controller
         * @param       restParams Parameters to provide to the GSCF rest method
         *
         * @return      ArrayList
         */
        private ArrayList callGSCF(String sessionToken, String restMethod, HashMap restParams = [:]) throws BadRequestException, NotAuthenticatedException, NotAuthorizedException, ResourceNotFoundException, Exception {

                def gscfResponse = []

                //construct addr
                def addr = "${this.restURL()}/${restMethod}?moduleURL=${this.moduleURL()}&consumer=${this.consumerID()}&token=${sessionToken}"

                // concat all Rest Call specific arguments behind addr
                restParams.each {parameter -> 
                        // If a list is given as value, the parameter should show up multiple times
                        if( parameter.value instanceof Collection ) {
                                parameter.value.each { value ->
                                        addr += "&${parameter.key}=${value}" 
                                }
                        } else {
                                addr += "&${parameter.key}=${parameter.value}"
                        } 
                }

                // Open the connection
                def connection;

                try {
                        log.info("GSCF REST-CALL: ${addr}")
                        connection = addr.toURL().openConnection()
                } catch( Exception e ) {
                        log.error("GSCF Call failed when calling service: ${addr}",e)
                        throw new Exception( "Calling GSCF Rest method ${restMethod} failed. Please check log for more information.", e )
                }

                switch( connection.responseCode ) {
                        case 400:       // Bad request
                                throw new BadRequestException( "Bad request made to GSCF server: " + addr );
                                break;
                        case 401:       // Not allowed to access this resource
                                throw new NotAuthorizedException( "User is not authorized to access the resource " + addr );
                                break;
                        case 403:       // Incorrect authentication
                                throw new NotAuthenticatedException( "User is not authenticated with GSCF." );
                                break;
                        case 404:       // Resource not found
                                throw new ResourceNotFoundException( "Specified resource could not be found: "  + addr );
                                break;
                        case 500:       // Internal server error
                                throw new Exception( "An unknown error occured when calling service: " + addr + " - " + connection.responseMessage )
                                break;
                        default:
                                try {
                                        def jsonResponse = JSON.parse(connection.content.text)
                                        jsonResponse.each { jsonProperty ->
                                                gscfResponse << jsonProperty
                                        }

                                        log.info("GSCF REST-RESP: ${jsonResponse}")
                                } catch(Exception e) {
                                        log.error("Parsing GSCF JSON response failed at ${addr}. Reponse was " + connection.content.text,e)
                                        throw new Exception( "Parsing GSCF JSON response failed at ${addr}.  Please check log for more information.", e )
                                }
                                break;
                }

                return gscfResponse
        }


        /**
         * Consumer ID for connection to of GSCF Rest Controller/API
         *
         * @return      consumerID      String
         */
        private String consumerID() {
                return config.metagenomics.consumerID
        }

        /**
         * Module URL for connection to of GSCF Rest Controller/API
         *
         * @return      moduleURL       String
         */
        private String moduleURL() {
                return config.metagenomics.baseURL
        }

}