org.directwebremoting.impl.DefaultDebugPageGenerator Maven / Gradle / Ivy

Go to download
package org.directwebremoting.impl;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.StringWriter;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.directwebremoting.extend.AccessControl;
import org.directwebremoting.extend.ConverterManager;
import org.directwebremoting.extend.DebugPageGenerator;
import org.directwebremoting.extend.DwrConstants;
import org.directwebremoting.extend.MethodDeclaration;
import org.directwebremoting.extend.Module;
import org.directwebremoting.extend.ModuleManager;
import org.directwebremoting.servlet.PathConstants;
import org.directwebremoting.util.CopyUtils;
import org.directwebremoting.util.JavascriptUtil;
import org.directwebremoting.util.LocalUtil;

/**
 * A default implementation of TestPageGenerator
 * @author Joe Walker [joe at getahead dot ltd dot uk]
 */
public class DefaultDebugPageGenerator implements DebugPageGenerator
{
    /* (non-Javadoc)
     * @see org.directwebremoting.DebugPageGenerator#generateIndexPage(java.lang.String)
     */
    public String generateIndexPage(final String root) throws SecurityException
    {
        if (!debug)
        {
            log.warn("Failed attempt to access test pages outside of debug mode. Set the debug init-parameter to true to enable.");
            throw new SecurityException("Access to debug pages is denied.");
        }

        StringBuffer buffer = new StringBuffer();

        buffer.append("\n");
        buffer.append("DWR Test Index\n");
        buffer.append("\n");

        buffer.append("Modules known to DWR:\n");
        buffer.append("\n");
        for (String name : moduleManager.getModuleNames(false))
        {
            Module module = moduleManager.getModule(name, false);

            buffer.append("");
            buffer.append(name);
            buffer.append(" (");
            buffer.append(module.toString());
            buffer.append(")\n");
        }
        buffer.append("\n");

        buffer.append("\n");

        return buffer.toString();
    }

    /* (non-Javadoc)
     * @see org.directwebremoting.DebugPageGenerator#generateTestPage(java.lang.String, java.lang.String)
     */
    public String generateTestPage(final String root, final String scriptName) throws SecurityException
    {
        if (!debug)
        {
            log.warn("Failed attempt to access test pages outside of debug mode. Set the debug init-parameter to true to enable.");
            throw new SecurityException("Access to debug pages is denied.");
        }

        String interfaceURL = root + interfaceHandlerUrl + scriptName + PathConstants.EXTENSION_JS;
        String engineURL = root + engineHandlerUrl;
        String utilURL = root + utilHandlerUrl;

        String proxyInterfaceURL = PATH_UP + interfaceHandlerUrl + scriptName + PathConstants.EXTENSION_JS;
        String proxyEngineURL = PATH_UP + engineHandlerUrl;
        String proxyUtilURL = PATH_UP + utilHandlerUrl;
        int slashPos = -1;
        while((slashPos = scriptName.indexOf('/', slashPos + 1)) != -1)
        {
            proxyInterfaceURL = PATH_UP + "/" + proxyInterfaceURL;
            proxyEngineURL = PATH_UP + "/" + proxyEngineURL;
            proxyUtilURL = PATH_UP + "/" + proxyUtilURL;
        }

        Module module = moduleManager.getModule(scriptName, true);
        MethodDeclaration[] methods = module.getMethods();
        StringBuffer buffer = new StringBuffer();

        buffer.append("\n");
        buffer.append("\n");
        buffer.append("  DWR Test\n");
        buffer.append("  \n");
        buffer.append("  \n");
        buffer.append("  \n");
        buffer.append("  \n");
        buffer.append("  \n");
        buffer.append("  \n");
        buffer.append("\n");
        buffer.append("\n");

        buffer.append("Methods For: " + scriptName + " (" + module.toString() + ")\n");
        buffer.append("To use this class in your javascript you will need the following script includes:\n");
        buffer.append("\n");
        buffer.append("  <script type='text/javascript' src='" + engineURL + "'></script>\n");
        buffer.append("  <script type='text/javascript' src='" + interfaceURL + "'></script>\n");
        buffer.append("\n");

        buffer.append("In addition there is an optional utility script:\n");
        buffer.append("\n");
        buffer.append("  <script type='text/javascript' src='" + utilURL + "'></script>\n");
        buffer.append("\n");

        buffer.append("Replies from DWR are shown with a yellow background if they are simple or in an alert box otherwise.
\n");
        buffer.append("The inputs are evaluated as Javascript so strings must be quoted before execution.\n");

        for (int i = 0; i < methods.length; i++)
        {
            MethodDeclaration method = methods[i];
            String methodName = method.getName();

            // Is it on the list of banned names
            if (JavascriptUtil.isReservedWord(methodName))
            {
                buffer.append("" + methodName + "() is not available because it is a reserved word.\n");
                continue;
            }

            buffer.append("\n");
            buffer.append("  " + methodName + '(');

            Class[] paramTypes = method.getParameterTypes();
            for (int j = 0; j < paramTypes.length; j++)
            {
                Class paramType = paramTypes[j];

                // The special type that we handle transparently
                if (LocalUtil.isServletClass(paramType))
                {
                    buffer.append("AUTO");
                }
                else
                {
                    String value = "";
                    if (paramType == String.class)
                    {
                        value = "\"\"";
                    }
                    else if (paramType == Boolean.class || paramType == Boolean.TYPE)
                    {
                        value = "true";
                    }
                    else if (paramType == Integer.class || paramType == Integer.TYPE || paramType == Short.class || paramType == Short.TYPE
                        || paramType == Long.class || paramType == Long.TYPE || paramType == Byte.class || paramType == Byte.TYPE)
                    {
                        value = "0";
                    }
                    else if (paramType == Float.class || paramType == Float.TYPE || paramType == Double.class || paramType == Double.TYPE)
                    {
                        value = "0.0";
                    }
                    else if (paramType.isArray() || Collection.class.isAssignableFrom(paramType))
                    {
                        value = "[]";
                    }
                    else if (Map.class.isAssignableFrom(paramType))
                    {
                        value = "{}";
                    }

                    buffer.append("    ");
                }

                buffer.append(j == paramTypes.length - 1 ? "" : ", \n");
            }
            buffer.append("  );\n");

            String onclick = (LocalUtil.isJavaIdentifierWithPackage(scriptName) ? scriptName : "dwr.engine._getObject(\"" + scriptName + "\")") + "." + methodName + "(";
            for (int j = 0; j < paramTypes.length; j++)
            {
                if (!LocalUtil.isServletClass(paramTypes[j]))
                {
                    onclick += "objectEval($(\"p" + i + j + "\").value), ";
                }
            }
            onclick += "reply" + i + ");";

            buffer.append("  \n");

            buffer.append("  \n");
            buffer.append("  \n");

            // Print a warning if this method is overloaded
            boolean overloaded = false;
            for (int j = 0; j < methods.length; j++)
            {
                if (j != i && methods[j].getName().equals(methodName))
                {
                    overloaded = true;
                }
            }
            if (overloaded)
            {
                buffer.append("
(Warning: overloaded methods are not recommended. See below)\n");
            }

            // Print a warning if the method uses un-marshallable types
            for (Class paramType1 : paramTypes)
            {
                if (!converterManager.isConvertable(paramType1))
                {
                    buffer.append("
(Warning: No Converter for " + paramType1.getName() + ". See below)\n");
                }
            }

            if (!converterManager.isConvertable(method.getReturnType()))
            {
                buffer.append("
(Warning: No Converter for " + method.getReturnType().getName() + ". See below)\n");
            }

            // See also the call to getReasonToNotExecute() above
            try
            {
                accessControl.assertGeneralDisplayable(scriptName, method);
            }
            catch (SecurityException ex)
            {
                buffer.append("
(Warning: " + methodName + "() is excluded: " + ex.getMessage() + ". See below)\n");
            }

            // We don't need to call assertExecutionIsPossible() because those
            // checks should be done by assertIsDisplayable() above
            // accessControl.assertExecutionIsPossible(creator, scriptName, method);

            buffer.append("\n");
        }

        buffer.append("\n");

        buffer.append("Other Links\n");
        buffer.append("\n");
        buffer.append("Back to module index.\n");
        buffer.append("\n");

        synchronized (scriptCache)
        {
            String output = scriptCache.get(PathConstants.FILE_HELP);
            if (output == null)
            {
                InputStream raw = LocalUtil.getInternalResourceAsStream(DwrConstants.PACKAGE_PATH + PathConstants.FILE_HELP);
                if (raw == null)
                {
                    log.error("Missing file " + PathConstants.FILE_HELP + ". Check the dwr.jar file was built to include html files.");
                    output = "Failed to read help text from resource file. Check dwr.jar is built to include html files.";
                }
                else
                {
                    BufferedReader in = new BufferedReader(new InputStreamReader(raw));
                    try
                    {
                        StringWriter writer = new StringWriter();
                        CopyUtils.copy(in, writer);
                        output = writer.toString();
                    }
                    catch (IOException ex)
                    {
                        log.error("Failed to read help text from resource file.", ex);
                        output = "Failed to read help text from resource file.";
                    }
                }

                scriptCache.put(PathConstants.FILE_HELP, output);
            }

            buffer.append(output);
        }

        buffer.append("\n");

        return buffer.toString();
    }

    /* (non-Javadoc)
     * @see org.directwebremoting.DebugPageGenerator#generateInterfaceUrl(java.lang.String, java.lang.String)
     */
    @Deprecated
    public String generateInterfaceUrl(String root, String scriptName)
    {
        return root + interfaceHandlerUrl + scriptName + PathConstants.EXTENSION_JS;
    }

    /* (non-Javadoc)
     * @see org.directwebremoting.DebugPageGenerator#generateEngineUrl(java.lang.String)
     */
    @Deprecated
    public String generateEngineUrl(String root)
    {
        return root + engineHandlerUrl;
    }

    /* (non-Javadoc)
     * @see org.directwebremoting.DebugPageGenerator#generateLibraryUrl(java.lang.String, java.lang.String)
     */
    @Deprecated
    public String generateLibraryUrl(String root, String library)
    {
        return root + library;
    }

    /* (non-Javadoc)
     * @see org.directwebremoting.DebugPageGenerator#getAvailableLibraries()
     */
    @Deprecated
    public Collection getAvailableLibraries()
    {
        if (availableLibraries == null)
        {
            availableLibraries = Collections.unmodifiableCollection(Arrays.asList(utilHandlerUrl));
        }

        return availableLibraries;
    }

    /**
     * Accessor for the DefaultConverterManager that we configure
     * @param converterManager The new DefaultConverterManager
     */
    public void setConverterManager(ConverterManager converterManager)
    {
        this.converterManager = converterManager;
    }

    /**
     * Accessor for the ModuleManager that we configure
     * @param moduleManager ...
     */
    public void setModuleManager(ModuleManager moduleManager)
    {
        this.moduleManager = moduleManager;
    }

    /**
     * Accessor for the security manager
     * @param accessControl The accessControl to set.
     */
    public void setAccessControl(AccessControl accessControl)
    {
        this.accessControl = accessControl;
    }

    /**
     * @param engineHandlerUrl the engineHandlerUrl to set
     */
    public void setEngineHandlerUrl(String engineHandlerUrl)
    {
        this.engineHandlerUrl = engineHandlerUrl;
    }

    /**
     * @param utilHandlerUrl the utilHandlerUrl to set
     */
    public void setUtilHandlerUrl(String utilHandlerUrl)
    {
        this.utilHandlerUrl = utilHandlerUrl;
    }

    /**
     * @param testHandlerUrl the testHandlerUrl to set
     */
    public void setTestHandlerUrl(String testHandlerUrl)
    {
        this.testHandlerUrl = testHandlerUrl;
    }

    /**
     * Setter for the URL that this handler available on
     * @param interfaceHandlerUrl the interfaceHandlerUrl to set
     */
    public void setInterfaceHandlerUrl(String interfaceHandlerUrl)
    {
        this.interfaceHandlerUrl = interfaceHandlerUrl;
    }

    /**
     * Setter for debug enabling
     * @param debug ...
     */
    public void setDebug(boolean debug)
    {
        this.debug = debug;
    }

    /**
     * The URL for the {@link org.directwebremoting.servlet.EngineHandler}
     */
    protected String engineHandlerUrl;

    /**
     * The URL for the {@link org.directwebremoting.ui.servlet.UtilHandler}
     */
    protected String utilHandlerUrl;

    /**
     * The URL for the {@link org.directwebremoting.servlet.TestHandler}
     */
    protected String testHandlerUrl;

    /**
     * What URL is this handler available on?
     */
    protected String interfaceHandlerUrl;

    /**
     * How we convert parameters
     */
    protected ConverterManager converterManager = null;

    /**
     * How we create new beans
     */
    protected ModuleManager moduleManager = null;

    /**
     * The security manager
     */
    protected AccessControl accessControl = null;

    /**
     * We cache the script output for speed
     */
    protected final Map scriptCache = new HashMap();

    /**
     * For getAvailableLibraries() - just a RO Collection that currently returns
     * only util.js, but may be expanded in the future.
     */
    private Collection availableLibraries = null;

    /**
     * Debug setting
     */
    private boolean debug = false;

    /**
     * 2 dots
     */
    private static final String PATH_UP = "..";

    /**
     * The log stream
     */
    private static final Log log = LogFactory.getLog(DefaultDebugPageGenerator.class);
}