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

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}&"

                def returnUrl = config.grails.serverURL
                if (params.controller != null){
                        returnUrl += "/${params.controller}"
                        if (params.action != null){
                                returnUrl += "/${params.action}"
                                if (params.id != null){
                                        returnUrl += "/${params.id}"
                                }
                        }
                }

                // Append other parameters
                returnUrl += "?" + params.collect {
                        if( it.key != "controller" && it.key != "action" && it.key != "id" )
                                return it.key.toString().encodeAsURL() + "=" + it.value.toString().encodeAsURL();
                        else
                                return ""
                }.findAll { it }.join( "&" );
                
                return redirectURL + "returnUrl=" + returnUrl.encodeAsURL();
        }

        /**
         * 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
        }

        /**
         * Retrieves the currently logged in user from GSCF
         *
         * @param sessionToken String
         *
         * @return Map
         */
        public Map getUser(String sessionToken) throws Exception {
                def user = [:]
                try {
                        this.callGSCF(sessionToken, "getUser").each {
                                user[ it.key ] = it.value;
                        }
                        return user
                } catch( Exception e ) {
                        e.printStackTrace();
                        return null
                        throw new Exception( "Retrieving user details from GSCF failed", e );
                }
        }

        /**
         * Retrieve a list of Studies from the GSCF
         * 
         * @param sessionToken String
         * 
         * @return ArrayList 
         */
        public ArrayList getStudies(String sessionToken) throws BadRequestException, NotAuthenticatedException, NotAuthorizedException, ResourceNotFoundException, Exception {
                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 ) throws BadRequestException, NotAuthenticatedException, NotAuthorizedException, ResourceNotFoundException, Exception  {
                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 BadRequestException, NotAuthenticatedException, NotAuthorizedException, ResourceNotFoundException, Exception  {
                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" )
                } // 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() ) {
                        return list[0];
                } else {
                        return []
                }
        }

        /**
         * Retrieve a list of Assays from the GSCF
         * 
         * @param sessionToken String
         * @param study Study 
         * 
         * @return ArrayList 
         */
        public ArrayList getAssays(String sessionToken, String studyToken) throws BadRequestException, NotAuthenticatedException, NotAuthorizedException, ResourceNotFoundException, Exception  {
                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 )throws BadRequestException, NotAuthenticatedException, NotAuthorizedException, ResourceNotFoundException, Exception  {
                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 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) throws BadRequestException, NotAuthenticatedException, NotAuthorizedException, ResourceNotFoundException, Exception  {
                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 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 BadRequestException, NotAuthenticatedException, NotAuthorizedException, ResourceNotFoundException, Exception  {
                // 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 BadRequestException, NotAuthenticatedException, NotAuthorizedException, ResourceNotFoundException, Exception  {
                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
        }


        /**
         * Retrieve study access
         *
         * @param sessionToken String
         * @param study Study
         *
         * @return ArrayList
         */
        public HashMap getAuthorizationLevel(String sessionToken, String studyToken) throws BadRequestException, NotAuthenticatedException, NotAuthorizedException, ResourceNotFoundException, Exception  {
                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.toString().encodeAsURL()
                                }
                        } else {
                                addr += "&${parameter.key}=" + parameter.value.toString().encodeAsURL()
                        }
                }

                // 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
                                println "Not authenticated (" + addr + "): " + connection.responseCode
                                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.grails.serverURL
        }

}