source: other-projects/the-macronizer/trunk/src/java/web/servlets/DirectInput.java@ 35722

package web.servlets;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.google.gson.Gson;
import com.google.gson.stream.JsonWriter;

import monogram.plugin.PluginConfiguration;
import monogram.plugin.PluginManager;

import org.apache.log4j.*;

import util.FileUtil;
import util.IOUtil;

/**
 * Represents a servlet for macronising direct text input.
 * @author OEM
 * @version 2.0
 */
public class DirectInput extends HttpServlet
{
    private static final String UTF8_ENCODING = "utf-8";

    //Create an instance of the logger object defined for this class in log4j.properties
    private static final Logger logger = Logger.getLogger(web.servlets.DirectInput.class.getName());
    
    private final Gson gsonInstance = new Gson();
    
    private File tmpdir;
    private PluginManager pluginManager;

    @Override
    public void init(ServletConfig config) throws ServletException
    {
        super.init(config);

        tmpdir = new File((String) config.getServletContext().getAttribute("tmpdir"));
        pluginManager = new PluginManager(tmpdir);
    }

    /** 
     * Handles the HTTP <code>GET</code> method.
     * @param request The servlet request.
     * @param response The servlet response.
     * @throws IllegalStateException if a reponse has already been committed.
     * @throws IOException if an I/O error occurs.
     */
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws IllegalStateException, IOException
    {
        response.sendError(405); // 405 Method Not Allowed
    }

    /** 
     * Handles the HTTP <code>POST</code> method.
     * @param request The servlet request.
     * @param response The servlet response.
     * @throws IllegalStateException if a response has already been committed.
     * @throws IOException if an I/O error occurs.
     * @throws ServletException if a servlet-specific error occurs.
     * @throws UnsupportedEncodingException if the selected encoding is not supported.
     */
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response)
        throws IllegalStateException, IOException, ServletException, UnsupportedEncodingException
    {
        request.setCharacterEncoding(UTF8_ENCODING);

        final String fragment = request.getParameter("fragment");
        final Boolean showAdvancedOptions = Boolean.parseBoolean(request.getParameter("options"));
        final Boolean shouldPreserveMacrons = Boolean.parseBoolean(request.getParameter("preserveExistingMacrons"));
        final OutputType outputType = OutputType.parse(request.getParameter("o"));

        // Note that the lang parameter might be null if the request hasn't been made from an internal JSP page
        final String forwardPath = request.getParameter("lang") != null
            ? "/jsp/" + request.getParameter("lang")
            : "/jsp/mi";

        try
        {
            final String restoredFragment = restoreMacrons
            (
                fragment,
                shouldPreserveMacrons,
                true
            );

            if (outputType == OutputType.Json)
            {
                response.setContentType("application/json; charset=UTF-8");
                JsonWriter writer = gsonInstance.newJsonWriter(response.getWriter());
                writer.beginArray();

                for (String element : restoredFragment.split("\\ "))
                {
                    writer.beginObject();

                    if (element.contains("<mark>"))
                    {
                        element = element.replace("<mark>", "").replace("</mark>", "");
                        writer.name("macronised");
                        writer.value(true);
                    }

                    writer.name("w");
                    writer.value(element);

                    writer.endObject();
                }
                
                writer.endArray();
                writer.flush();
            }
            else
            {
                request.setAttribute("fragment2", restoredFragment);
                request.setAttribute("old", fragment);
                request.setAttribute("options", showAdvancedOptions.toString());
                request.setAttribute("preserveMacrons", shouldPreserveMacrons.toString());
    
                forward(forwardPath + "/main.jsp", request, response);
            }
    
            logger.debug("Macron restoration succeeded. Input: " + fragment + " | Output: " + restoredFragment);
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
            logger.error("Failed to restore macrons", ex);

            switch (outputType) {
                case Json:
                    // 500 Internal Server Error
                    response.sendError(500, "An unexpected error has occurred. Please try again or contact the web administrator if the problem persists.");
                    break;
                default:
                    request.setAttribute("errorMessage", "UNEXPECTED_ERROR");
                    forward(forwardPath + "/error.jsp", request, response);
                    break;
            }
        }
    }

    /**
     * Restores macrons on an input fragment.
     * @param input The input fragment to restore.
     * @param preserveMacrons Indicates whether existing macrons on the input should be preserved.
     * @return The macronised fragment.
     * @throws IOException
     * @throws UnsupportedOperationException
     * @throws Exception
     */
    private String restoreMacrons(String input, boolean preserveMacrons, boolean markupChangedWords)
        throws IOException, UnsupportedOperationException, Exception
    {
        //Write the input to a temporary file.
        File inputFile = File.createTempFile(FileUtil.TMP_FILE_PREFIX, ".txt", tmpdir);
        write(inputFile, UTF8_ENCODING, input);
        
        //Create a fileview
        PluginConfiguration configuration = new PluginConfiguration();
        configuration.setFile(inputFile);
        configuration.setCharsetEncoding(UTF8_ENCODING);
        configuration.setFileType(".txt");
        configuration.setPreserveExistingMacrons(preserveMacrons);
        configuration.setMarkupChangedWords(markupChangedWords);

        //Restore the file.
        File restoredFile = null;

        try
        {
            restoredFile = pluginManager.run(configuration);
            return read(restoredFile, UTF8_ENCODING).trim();
        }
        finally
        {
            inputFile.delete();

            if (restoredFile != null)
            {
                restoredFile.delete();
            }
        }
    }

    /**
     * Forwards a request from a servlet to another resource on the server.
     * @param path The path to forward to.
     * @param request The servlet request.
     * @param response The servlet response.
     * @throws ServletException
     * @throws IOException
     */
    private void forward(String path, HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException
    {
        final RequestDispatcher dispatcher = getServletContext().getRequestDispatcher(path);
        dispatcher.forward(request, response);
    }

    /**
     * Writes the fragment to the file.
     * @param file The file to write to.
     * @param fragment The String to write to the file.
     * @throws IOException
     */
    private void write(File file, String charsetEncoding, String fragment)
        throws IOException
    {
        BufferedWriter out = null;
        try
        {
            out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), charsetEncoding));
            out.write(fragment);
        }
        finally
        {
            IOUtil.closeWriter(out);
        }
    }

    /**
     * Reads the contents of the file.
     * @param file The file to read.
     * @param charsetEncoding The character set encoding of the file.
     * @return The contents of the file.
     * @throws IOException
     */
    private String read(File file, String charsetEncoding)
        throws IOException
    {
        final StringBuilder buffer = new StringBuilder();
        BufferedReader reader = null;

        try
        {
            reader = new BufferedReader(new InputStreamReader(new FileInputStream(file), charsetEncoding));
            final char[] chars = new char[1024];
            int numRead = 0;

            while ((numRead = reader.read(chars)) > -1)
            {
                buffer.append(String.valueOf(chars, 0, numRead));
            }
        }
        finally
        {
            IOUtil.closeReader(reader);
        }

        return buffer.toString();
    }
}