source: ether_ndacc/trunk/web/src/com/ether/ControllerEther.java @ 204

package com.ether;

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;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

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 com.ether.annotation.ControllerMethod;
import com.ether.annotation.Mandatory;
import com.ether.annotation.ParamName;
import com.ether.annotation.UseJSON;

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


                        request.setCharacterEncoding(UTF8Charset.getEncoding());

                        final String methodName = _methodNameResolver.getHandlerMethodName(request);

                        final MethodDescription methodDescription = _methods.get(methodName);
                        if (null == methodDescription) {
                                WebHelper.displayError( response, 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);

                        // Invoke method (go to controller)
                        final Object result = methodDescription.getMethod().invoke(this, params);

                        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 {
                                response.setStatus(HttpServletResponse.SC_NO_CONTENT);
                                return null;
                        }
                } catch (Throwable e) {
                        throw new WebException(e);
                }
        }

        @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;
    }

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