source: tapas/web/src/com/ether/ControllerEther.java @ 440

package com.ether;

import com.ether.annotation.ControllerMethod;
import com.ether.annotation.Mandatory;
import com.ether.annotation.ParamName;
import com.ether.annotation.UseJSON;
import com.ether.user.User;
import net.sf.json.JSON;
import net.sf.json.JSONArray;
import net.sf.json.JSONNull;
import net.sf.json.JSONObject;
import net.sf.json.util.JSONUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.springframework.beans.factory.annotation.Required;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.AbstractController;
import org.springframework.web.servlet.mvc.multiaction.MethodNameResolver;
import org.springframework.web.servlet.mvc.multiaction.NoSuchRequestHandlingMethodException;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.security.InvalidParameterException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class ControllerEther
        extends AbstractController
{
    /**
     * This method is used to change Locale with the framework Spring
     *
     * @throws WebException
     */
    @ControllerMethod()
    public void setLocale()
            throws WebException
    {
    }

    /**
     * This method returns a property writed in the properties file
     *
     * @return
     * @throws WebException
     */
    public String getProperty( @NotNull final String property )
            throws WebException
    {
        try
        {
            final String webInfPath = getServletContext().getRealPath( "WEB-INF" );
            return WebHelper.getProperty( webInfPath, property );
        }
        catch( IOException e )
        {
            throw new WebException( WebException.WebCode.ERROR_TO_READ_FILE_PROPERTIES, e );
        }
    }

    @Override
    @Nullable
    protected ModelAndView handleRequestInternal( @NotNull final HttpServletRequest request, @NotNull final HttpServletResponse response )
            throws WebException
    {
        try
        {
            if( !_initialized )
                initialize();

            request.setCharacterEncoding( UTF8Charset.getEncoding() );

            // Get method to call
            final String methodName = _methodNameResolver.getHandlerMethodName( request );

            final MethodDescription methodDescription = _methods.get( methodName );
            if( null == methodDescription )
            {
                WebHelper.displayAjaxError( response, methodName );
                if( LOGGER.isWarnEnabled() )
                    LOGGER.warn( String.format( "Controller=%1$s Method=%2$s METHOD NOT FOUND", getClass().getSimpleName(), methodName ) );
                return null;
            }

            return invokeMethod( methodDescription, request, response );
        }
        catch( UnsupportedEncodingException e )
        {
            throw new WebException( WebException.WebCode.ERROR_UNSUPPORTED_UTF8_ENCODING, e );
        }
        catch( NoSuchRequestHandlingMethodException e )
        {
            throw new WebException( WebException.WebCode.ERROR_NO_REQUEST_HANDLING_METHOD, e );
        }
    }

    @Nullable
    private ModelAndView invokeMethod( @NotNull final MethodDescription methodDescription, @NotNull final HttpServletRequest request, @NotNull final HttpServletResponse response )
            throws WebException
    {
        try
        {
            // Parse parameters
            final Object[] params = buildParams( methodDescription, request );
            final String defaultView = ( null != methodDescription.getDefaultView() && !"".equals( methodDescription.getDefaultView() ) ) ? methodDescription.getDefaultView() : methodDescription.getView();


            if( methodDescription.isRequestMandatory() )
                params[params.length - 1] = request; //params = parametre de la methode du Controller


            if( methodDescription.isLoginMandatory() )
            {
                final User user = (User) request.getSession().getAttribute( "SES_USER" );
                if( null == user )
                    return new ModelAndView( defaultView, "errors", "login.error.unknown" );
            }

            if (methodDescription.isUserMandatory()) {
                final User user = (User) request.getSession().getAttribute( "SES_USER" );

                if( null == user )
                    return new ModelAndView( defaultView, "errors", "login.error.unknown" );
                else
                    params[params.length - 1] = user;

            }

            if( methodDescription.isBackofficeMethod() )
            {
                final User user = (User) request.getSession().getAttribute( "SES_USER" );
                if( null == user )
                {
                    return new ModelAndView( defaultView, "errors", "login.error.unknown" );
                }
                else if( null != user && !user.isAccessToBO() )
                {
                    return new ModelAndView( defaultView, "errors", "login.error.bo.notAccepted" );
                }
            }

            final Object result;
            try
            {
                // Invoke method (go to controller)
                result = methodDescription.getMethod().invoke( this, params );
            }
            catch( Throwable e )
            {
                sendSerializedException( response, e.getCause() );
                return null;
            }

            // Return result
            if( !methodDescription.getView().isEmpty() )
            {
                response.setStatus( HttpServletResponse.SC_OK );
                if( result instanceof Map )
                    return new ModelAndView( methodDescription.getView(), (Map) result );
                else
                    return new ModelAndView( methodDescription.getView(), "result", result );
            }
            else if( methodDescription.isJsonResult() )
            {
                response.setStatus( HttpServletResponse.SC_OK );
                final String jsonResult = convertToJson( result );
                WebHelper.writeJsonToResponse( response, jsonResult );
                return null;
            }
            else if( null != methodDescription.getDownloadFile() && !"".equals( methodDescription.getDownloadFile() ) )
            {
                final String fileName = methodDescription.getDownloadFile();
                final String downloadPath = getProperty( "downloadPath" );

                response.setContentType( "multipart/zip" );
                response.setHeader( "Content-Disposition", "attachment; filename=\"" + fileName.trim() + "\";" );

                final File file = new File( downloadPath + fileName );
                if( !file.exists() )
                    throw new WebException( WebException.WebCode.ERROR_TO_DOWNLOAD_FILE, file.getPath() );

                response.setContentLength( (int) file.length() );
                try
                {
                    final OutputStream outputStream = response.getOutputStream();
                    final FileInputStream fileInputStream = new FileInputStream( file );

                    final BufferedInputStream bufferedInputStream = new BufferedInputStream( fileInputStream );
                    final InputStream inputStream = new BufferedInputStream( bufferedInputStream );

                    int count;
                    final byte[] buf = new byte[4096];
                    while( ( count = inputStream.read( buf ) ) > -1 )
                        outputStream.write( buf, 0, count );
                    inputStream.close();
                    outputStream.close();
                }
                catch( Exception ex )
                {
                    throw new WebException( WebException.WebCode.ERROR_TO_DOWNLOAD_FILE, ex );
                }
                return null;
            }
            else
            {
                response.setStatus( HttpServletResponse.SC_NO_CONTENT );
                return null;
            }
        }
        catch( Throwable e )
        {
            throw new WebException( e );
        }
    }

    private void sendSerializedException( @NotNull final HttpServletResponse response, @NotNull final Throwable exception )
            throws IOException
    {
        response.setStatus( WebHelper.STATUS_CODE_SERVICE_EXCEPTION );

        if( exception.getCause().equals( WebException.getExceptionThrowable() ) )
            WebHelper.writeJsonToResponse( response, exception.getLocalizedMessage() );
        else
            WebHelper.writeJsonToResponse( response, _jsonHelper.toJSONObject( exception ).toString() );
    }

    @NotNull
    private String convertToJson( @Nullable final Object object )
    {
        if( null == object )
            return JSONNull.getInstance().toString();
        if( object instanceof JSON )
            return object.toString();
        if( object instanceof Collection )
            return _jsonHelper.toJSON( (Collection) object ).toString();
        if( object.getClass().isArray() )
            return _jsonHelper.toJSON( object ).toString();
        if( object instanceof Number || object instanceof Boolean || object instanceof String )
            return JSONUtils.valueToString( object );
        return _jsonHelper.toJSON( object ).toString();
    }

    @NotNull
    private Object[] buildParams( @NotNull final MethodDescription methodDescription, @NotNull final HttpServletRequest request )
            throws InvalidParameterException
    {
        final List<Object> params = new ArrayList<Object>();
        for( final ParamDescription paramDescription : methodDescription.getParams() )
        {
            if( null == paramDescription )
            {
                params.add( null );
                continue;
            }
            final boolean canBeNull = !paramDescription.isPrimitive() && !paramDescription.isMandatory();
            final String paramValue = WebHelper.getRequestParameter( request, paramDescription.getName(), null, canBeNull );
            final boolean useJSON = paramDescription.isUsingJSON();
            params.add( convertParameter( paramDescription.getType(), paramValue, useJSON ) );
        }
        return params.toArray( new Object[params.size()] );
    }

    @Nullable
    private Object convertParameter( @NotNull final Class paramType, @Nullable final String paramValue, final boolean useJSON )
    {
        if( null == paramValue )
            return null;
        if( useJSON )
            return _jsonHelper.fromJSON( _jsonHelper.toJSON( paramValue ), paramType );
        if( JSONObject.class.equals( paramType ) )
            return _jsonHelper.toJSON( paramValue );
        if( JSONArray.class.equals( paramType ) )
            return _jsonHelper.toJSON( paramValue );
        if( String.class.equals( paramType ) )
            return paramValue;
        if( Boolean.TYPE.equals( paramType ) || Boolean.class.equals( paramType ) )
            return Boolean.valueOf( paramValue );
        if( Integer.TYPE.equals( paramType ) || Integer.class.equals( paramType ) )
            return Integer.valueOf( paramValue );
        if( Long.TYPE.equals( paramType ) || Long.class.equals( paramType ) )
            return Long.valueOf( paramValue );
        if( Float.TYPE.equals( paramType ) || Float.class.equals( paramType ) )
            return Float.valueOf( paramValue );
        if( Double.TYPE.equals( paramType ) || Double.class.equals( paramType ) )
            return Double.valueOf( paramValue );
        if( Date.class.isAssignableFrom( paramType ) )
            return new Date( Long.valueOf( paramValue ) );
        if( paramType.isEnum() )
            return Enum.valueOf( paramType, paramValue );
        if( Map.class.isAssignableFrom( paramType ) )
            return JSONObject.fromObject( paramValue );

        throw new UnsupportedOperationException( "Unsupported: cast parameter to " + paramType.getName() );
    }

    private void initialize()
            throws WebException
    {
        for( final Method method : getClass().getMethods() )
        {
            final ControllerMethod annotation = method.getAnnotation( ControllerMethod.class );
            if( null != annotation )
            {
                final MethodDescription methodDescription = new MethodDescription( method, annotation );
                fillMethodDescription( method, methodDescription );
                _methods.put( method.getName(), methodDescription );
            }
        }

        _initialized = true;
    }

    private void fillMethodDescription( @NotNull final Method method, @NotNull final MethodDescription methodDescription )
            throws WebException
    {
        final Class<?>[] paramTypes = method.getParameterTypes();
        final Annotation[][] paramAnnotations = method.getParameterAnnotations();

        if( paramTypes.length != paramAnnotations.length )
            throw new WebException( WebException.WebCode.ERROR_NUMBER_OF_PARAM_TYPES_NOT_EQUAL_TO_PARAM_ANNOTATIONS, paramTypes.length + " " + paramAnnotations.length );

        for( int i = 0; i < paramTypes.length; ++i )
        {
            ParamName paramNameAnnotation = null;
            Mandatory mandatoryAnnotation = null;
            UseJSON useJSONAnnotation = null;
            for( final Annotation paramAnnotation : paramAnnotations[i] )
            {
                if( paramAnnotation instanceof ParamName )
                    paramNameAnnotation = (ParamName) paramAnnotation;
                if( paramAnnotation instanceof Mandatory )
                    mandatoryAnnotation = (Mandatory) paramAnnotation;
                if( paramAnnotation instanceof UseJSON )
                    useJSONAnnotation = (UseJSON) paramAnnotation;
            }
            if( null == paramNameAnnotation )
                methodDescription.addNullParam();
            else
            {
                final boolean mandatory = ( null != mandatoryAnnotation );
                final boolean useJSON = ( null != useJSONAnnotation );
                methodDescription.addParam( paramNameAnnotation.value(), paramTypes[i], mandatory, useJSON );
            }
        }
    }

    @Required
    public void setMethodNameResolver( final MethodNameResolver methodNameResolver )
    {
        _methodNameResolver = methodNameResolver;
    }

    protected JSONHelper getJsonHelper()
    {
        return _jsonHelper;
    }

    @Required
    public void setJsonHelper( final JSONHelper jsonHelper )
    {
        _jsonHelper = jsonHelper;
    }

    protected Map<String, MethodDescription> getMethods()
    {
        return _methods;
    }

    @Required
    public void setTapasService( @NotNull final TapasService tapasService )
    {
        _tapasService = tapasService;
    }

    public TapasService getTapasService()
    {
        return _tapasService;
    }

    private static final Log LOGGER = LogFactory.getLog( ControllerEther.class );

    private JSONHelper _jsonHelper;
    private MethodNameResolver _methodNameResolver;
    private Map<String, MethodDescription> _methods = new HashMap<String, MethodDescription>();
    private boolean _initialized; /*=false*/

    private TapasService _tapasService;
}