org.ctoolkit.restapi.client.adapter.RestFacadeAdapter Maven / Gradle / Ivy

Go to download
/*
 * Copyright (c) 2017 Comvai, s.r.o. All Rights Reserved.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

package org.ctoolkit.restapi.client.adapter;

import com.google.api.client.googleapis.media.MediaHttpDownloader;
import com.google.api.client.http.GenericUrl;
import com.google.api.client.http.HttpHeaders;
import com.google.api.client.http.HttpRequestInitializer;
import com.google.api.client.http.HttpResponseException;
import com.google.api.client.http.HttpStatusCodes;
import com.google.common.collect.Lists;
import com.google.inject.Binding;
import com.google.inject.Injector;
import com.google.inject.Key;
import com.google.inject.TypeLiteral;
import com.google.inject.util.Types;
import ma.glasnost.orika.MapperFacade;
import ma.glasnost.orika.MapperFactory;
import ma.glasnost.orika.metadata.Type;
import ma.glasnost.orika.metadata.TypeFactory;
import org.ctoolkit.restapi.client.ClientErrorException;
import org.ctoolkit.restapi.client.DeleteIdentification;
import org.ctoolkit.restapi.client.DownloadMediaProvider;
import org.ctoolkit.restapi.client.DownloadRequest;
import org.ctoolkit.restapi.client.ForbiddenException;
import org.ctoolkit.restapi.client.HttpFailureException;
import org.ctoolkit.restapi.client.Identifier;
import org.ctoolkit.restapi.client.NotFoundException;
import org.ctoolkit.restapi.client.PayloadRequest;
import org.ctoolkit.restapi.client.RemoteServerErrorException;
import org.ctoolkit.restapi.client.RequestCredential;
import org.ctoolkit.restapi.client.RestFacade;
import org.ctoolkit.restapi.client.RetrievalRequest;
import org.ctoolkit.restapi.client.ServiceUnavailableException;
import org.ctoolkit.restapi.client.SingleRetrievalIdentification;
import org.ctoolkit.restapi.client.UnauthorizedException;
import org.ctoolkit.restapi.client.UpdateIdentification;
import org.ctoolkit.restapi.client.UploadMediaProvider;
import org.ctoolkit.restapi.client.adaptee.DeleteExecutorAdaptee;
import org.ctoolkit.restapi.client.adaptee.DownloadExecutorAdaptee;
import org.ctoolkit.restapi.client.adaptee.GetExecutorAdaptee;
import org.ctoolkit.restapi.client.adaptee.InsertExecutorAdaptee;
import org.ctoolkit.restapi.client.adaptee.ListExecutorAdaptee;
import org.ctoolkit.restapi.client.adaptee.MediaProvider;
import org.ctoolkit.restapi.client.adaptee.NewExecutorAdaptee;
import org.ctoolkit.restapi.client.adaptee.UnderlyingClientAdaptee;
import org.ctoolkit.restapi.client.adaptee.UpdateExecutorAdaptee;
import org.ctoolkit.restapi.client.provider.LocalListResourceProvider;
import org.ctoolkit.restapi.client.provider.LocalResourceProvider;
import org.ctoolkit.restapi.client.provider.TokenProvider;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import javax.inject.Inject;
import javax.net.ssl.SSLHandshakeException;
import java.io.IOException;
import java.io.OutputStream;
import java.lang.reflect.ParameterizedType;
import java.net.SocketTimeoutException;
import java.net.URL;
import java.net.UnknownHostException;
import java.security.GeneralSecurityException;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;

import static com.google.common.base.Preconditions.checkNotNull;
import static java.util.Objects.requireNonNull;

/**
 * The Fluent facade API implementation as an adapter. Executes Java bean mapping
 * and then delegates the execution to one of the binded adaptee.
 *
 * @author Aurel Medvegy
 * @see MapperFactory
 */
public class RestFacadeAdapter
        implements RestFacade
{
    private static final Logger logger = LoggerFactory.getLogger( RestFacadeAdapter.class );

    private final MapperFacade mapper;

    private final MapperFactory factory;

    private final Injector injector;

    private final GoogleApiProxyFactory apiFactory;

    private final Map apis;

    private Substitute substitute;

    @Inject
    RestFacadeAdapter( MapperFacade mapper,
                       MapperFactory factory,
                       Injector injector,
                       GoogleApiProxyFactory apiFactory,
                       Map apis )
    {
        this.mapper = mapper;
        this.factory = factory;
        this.injector = injector;
        this.apiFactory = apiFactory;
        this.apis = apis;
    }

    @com.google.inject.Inject( optional = true )
    public void setSubstitute( Substitute substitute )
    {
        this.substitute = substitute;
    }

    /**
     * Returns the mapper instance.
     *
     * @return the mapper instance
     */
    MapperFacade getMapper()
    {
        return mapper;
    }

    /**
     * Executes download. Call to remote endpoint.
     *
     * @param downloader  the http downloader to interact with
     * @param adaptee     the download adaptee configured for given resource
     * @param resource    the type of resource to download as a media
     * @param identifier  the unique identifier of content to download
     * @param output      the output stream where desired content will be downloaded to.
     * @param interceptor the response interceptor
     * @param headers     the HTTP request headers
     * @param params      the optional resource params
     * @param locale      the language the client has configured to prefer in results if applicable
     * @return the download's response headers.
     */
    Map executeDownload( @Nonnull MediaHttpDownloader downloader,
                                         @Nonnull DownloadExecutorAdaptee adaptee,
                                         @Nonnull Class resource,
                                         @Nonnull Identifier identifier,
                                         @Nonnull OutputStream output,
                                         @Nonnull DownloadResponseInterceptor interceptor,
                                         @Nullable HttpHeaders headers,
                                         @Nullable Map params,
                                         @Nullable Locale locale )
    {
        //noinspection MismatchedQueryAndUpdateOfCollection
        RequestCredential credential = new RequestCredential();
        credential.fillInFrom( params, false );
        String type = headers == null ? null : headers.getContentType();

        URL path = requireNonNull( adaptee ).prepareDownloadUrl( identifier.root(), type, params, locale );
        if ( path == null )
        {
            String msg = "URL to download a resource content cannot be null. Identifier: ";
            throw new IllegalArgumentException( msg + identifier + " Resource: " + resource.getName() );
        }

        try
        {
            boolean remote = substitute == null;
            if ( !remote )
            {
                try
                {
                    substitute.download( checkNotNull( resource ),
                            identifier,
                            checkNotNull( output ),
                            headers,
                            params,
                            locale );
                }
                catch ( Substitute.ProceedWithRemoteCall e )
                {
                    remote = true;
                }
            }

            if ( remote )
            {
                requireNonNull( downloader ).download( new GenericUrl( path ), headers, output );
            }
        }
        catch ( IOException e )
        {
            // Update exception handling is being used. We need to return exception if resource is not found.
            throw prepareUpdateException( e, resource, identifier );
        }
        return interceptor.getHeaders();
    }

    /**
     * Prepares the configured download request
     *
     * @param resource   the type of resource to download as a media
     * @param identifier the unique identifier of content to download
     * @param output     the output stream where desired content will be downloaded to.
     * @param type       the content type or {@code null} to expect default
     * @return the configured download request
     */
    DownloadRequest prepareDownloadRequest( @Nonnull Class resource,
                                            @Nonnull Identifier identifier,
                                            @Nonnull OutputStream output,
                                            @Nullable String type )
    {
        DownloadResponseInterceptor interceptor = new DownloadResponseInterceptor();
        DownloadExecutorAdaptee adaptee = adaptee( DownloadExecutorAdaptee.class, checkNotNull( resource ) );
        String apiPrefix = adaptee.getApiPrefix();
        MediaHttpDownloader downloader;

        try
        {
            HttpRequestInitializer requestConfig = apiFactory.newRequestConfig( apiPrefix, interceptor );
            downloader = new MediaHttpDownloader( apiFactory.getHttpTransport(), requestConfig );
        }
        catch ( GeneralSecurityException e )
        {
            logger.error( "Application name: " + apiFactory.getApplicationName( apiPrefix )
                    + " Endpoint URL: " + apiFactory.getEndpointUrl( apiPrefix ), e );
            throw new UnauthorizedException( e.getMessage() );
        }
        catch ( IOException e )
        {
            logger.error( "Application name: " + apiFactory.getApplicationName( apiPrefix )
                    + " Endpoint URL: " + apiFactory.getEndpointUrl( apiPrefix ), e );

            throw new RemoteServerErrorException( e.getMessage() );
        }

        Identifier root = checkNotNull( identifier ).root();
        OutputStream os = checkNotNull( output );
        return new DownloadRequestImpl( this, adaptee, downloader, resource, root, os, interceptor, type );
    }

    @Override
    public  PayloadRequest newInstance( @Nonnull Class resource )
    {
        NewExecutorAdaptee adaptee = adaptee( NewExecutorAdaptee.class, checkNotNull( resource ) );
        Object remoteRequest;
        try
        {
            remoteRequest = adaptee.prepareNew( resource.getSimpleName() );
        }
        catch ( IOException e )
        {
            throw new ClientErrorException( e.getMessage() );
        }

        return new NewInstanceRequest<>( resource, this, adaptee, remoteRequest );
    }

    @Override
    public  UploadMediaProvider upload( @Nonnull T resource )
    {
        return new InputStreamUploadMediaRequestProvider<>( this, checkNotNull( resource ) );
    }

    @Override
    public  DownloadMediaProvider download( @Nonnull Class resource )
    {
        return new OutputStreamDownloadMediaRequestProvider( this, checkNotNull( resource ) );
    }

     R callbackNewInstance( @Nonnull NewExecutorAdaptee adaptee,
                               @Nonnull Object remoteRequest,
                               @Nonnull Class responseType,
                               @Nullable Map parameters,
                               @Nullable Locale locale )
    {
        if ( parameters == null )
        {
            parameters = new HashMap<>();
        }

        Object remoteInstance = null;
        try
        {
            boolean remote = substitute == null;
            if ( !remote )
            {
                try
                {
                    remoteInstance = substitute.newInstance( checkNotNull( remoteRequest ),
                            checkNotNull( responseType ),
                            parameters,
                            locale );
                }
                catch ( Substitute.ProceedWithRemoteCall e )
                {
                    remote = true;
                }
            }

            if ( remote )
            {
                remoteInstance = adaptee.executeNew( remoteRequest, parameters, locale );
            }
        }
        catch ( IOException e )
        {
            throw prepareUpdateException( e, responseType, null );
        }

        checkNotNull( remoteInstance, "Callback must not return null" );
        if ( remoteInstance.getClass() == responseType )
        {
            //noinspection unchecked
            return ( R ) remoteInstance;
        }
        else
        {
            return mapper.map( remoteInstance, responseType );
        }
    }

    @Override
    public  SingleRetrievalIdentification get( @Nonnull Class resource )
    {
        return new SingleRetrievalIdentificationImpl<>( this, resource );
    }

     RetrievalRequest internalGet( @Nonnull Class resource, @Nonnull Identifier identifier )
    {
        GetExecutorAdaptee adaptee = adaptee( GetExecutorAdaptee.class, checkNotNull( resource ) );
        Object remoteRequest;
        try
        {
            String errorMessage = "Identifier for GET operation cannot be null.";
            remoteRequest = adaptee.prepareGet( checkNotNull( identifier, errorMessage ) );
        }
        catch ( IOException e )
        {
            throw new ClientErrorException( e.getMessage() );
        }

        return new GetRequest<>( resource, identifier.root(), this, adaptee, remoteRequest );
    }

     R callbackExecuteGet( @Nonnull GetExecutorAdaptee adaptee,
                              @Nonnull Object remoteRequest,
                              @Nonnull Class responseType,
                              @Nonnull Identifier identifier,
                              @Nullable Map parameters,
                              @Nullable Locale locale )
    {
        if ( parameters == null )
        {
            parameters = new HashMap<>();
        }

        // looking for LocalResourceProvider optional implementation for given resource type
        LocalResourceProvider provider = getExistingResourceProvider( checkNotNull( responseType ) );
        R response = null;

        boolean requestForPersist = false;
        if ( provider != null )
        {
            // retrieve requested local resource
            response = provider.get( identifier.root(), parameters, locale );
            requestForPersist = response == null;
        }

        if ( response == null )
        {
            Object remoteObject = null;
            try
            {
                boolean remote = substitute == null;
                if ( !remote )
                {
                    try
                    {
                        remoteObject = substitute.get( remoteRequest, responseType, identifier, parameters, locale );
                    }
                    catch ( Substitute.ProceedWithRemoteCall e )
                    {
                        remote = true;
                    }
                }

                if ( remote )
                {
                    remoteObject = adaptee.executeGet( remoteRequest, parameters, locale );
                }
            }
            catch ( IOException e )
            {
                RuntimeException exception = prepareRetrievalException( e, responseType, identifier );
                if ( exception == null )
                {
                    return null;
                }
                else
                {
                    throw exception;
                }
            }

            checkNotNull( remoteObject, "Callback must not return null" );
            if ( remoteObject.getClass() == responseType )
            {
                //noinspection unchecked
                response = ( R ) remoteObject;
            }
            else
            {
                response = mapper.map( remoteObject, responseType );
            }
        }

        if ( requestForPersist && response != null )
        {
            // TODO resource provider lastFor not implemented yet
            // provide remote resource instance to be either persisted or cached
            provider.persist( response, identifier.root(), parameters, locale, null );
        }
        return response;
    }

    @Override
    public  ListRequest list( @Nonnull Class resource )
    {
        return list( resource, null );
    }

    @Override
    public  ListRequest list( @Nonnull Class resource, @Nullable Identifier parent )
    {
        ListExecutorAdaptee adaptee = adaptee( ListExecutorAdaptee.class, checkNotNull( resource ) );
        Object remoteRequest;
        try
        {
            remoteRequest = adaptee.prepareList( parent == null ? null : parent.root() );
        }
        catch ( IOException e )
        {
            throw new ClientErrorException( e.getMessage() );
        }

        return new ListRequest<>( resource, this, adaptee, remoteRequest );
    }

     List callbackExecuteList( @Nonnull ListExecutorAdaptee adaptee,
                                     @Nonnull Object remoteRequest,
                                     @Nonnull Class responseType,
                                     @Nullable Map criteria,
                                     @Nullable Locale locale,
                                     int start,
                                     int length,
                                     @Nullable String orderBy,
                                     @Nullable Boolean ascending )
    {
        if ( criteria == null )
        {
            criteria = new HashMap<>();
        }

        // looking for LocalResourceProvider optional implementation for given resource type
        LocalListResourceProvider provider = getExistingListResourceProvider( checkNotNull( responseType ) );
        List response = null;

        boolean requestForPersist = false;
        if ( provider != null )
        {
            // retrieve requested local list of resources
            response = provider.list( criteria, locale, null );
            requestForPersist = response == null;
        }

        if ( response == null )
        {
            List remoteList = null;
            try
            {
                boolean remote = substitute == null;
                if ( !remote )
                {
                    try
                    {
                        remoteList = substitute.list( remoteRequest, responseType, criteria,
                                locale, start, length, orderBy, ascending );
                    }
                    catch ( Substitute.ProceedWithRemoteCall e )
                    {
                        remote = true;
                    }
                }

                if ( remote )
                {
                    //noinspection unchecked
                    remoteList = adaptee.executeList( remoteRequest, criteria, locale, start, length, orderBy, ascending );
                }
            }
            catch ( IOException e )
            {
                RuntimeException exception = prepareRetrievalException( e, responseType, null );
                if ( exception == null )
                {
                    remoteList = null;
                }
                else
                {
                    throw exception;
                }
            }
            if ( remoteList == null || remoteList.isEmpty() )
            {
                response = Lists.newArrayList();
            }
            else
            {
                if ( remoteList.get( 0 ).getClass() == responseType )
                {
                    response = remoteList;
                }
                else
                {
                    response = mapper.mapAsList( remoteList, responseType );
                }
            }
        }

        if ( requestForPersist && response != null && !response.isEmpty() )
        {
            // provide remote list of resource to be either persisted or cached
            provider.persistList( response, criteria, locale, null );
        }
        return response;
    }

    @Override
    public  PayloadRequest insert( @Nonnull T resource )
    {
        return insert( resource, null );
    }

    @Override
    public  PayloadRequest insert( @Nonnull T resource, @Nullable Identifier parentKey )
    {
        return internalInsert( resource, parentKey, null );
    }

     PayloadRequest internalInsert( @Nonnull T resource,
                                          @Nullable Identifier parentKey,
                                          @Nullable MediaProvider provider )
    {
        Class remoteResource = evaluateRemoteResource( checkNotNull( resource ).getClass() );
        Object source;

        if ( resource.getClass() == remoteResource )
        {
            source = resource;
        }
        else
        {
            source = mapper.map( resource, remoteResource );
        }

        @SuppressWarnings( "unchecked" )
        InsertExecutorAdaptee