source: other-projects/the-macronizer/trunk/src/java/web/servlets/FileUpload.java@ 31964

package web.servlets;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.lang.StringBuilder;
import java.util.List;
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 org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;
import monogram.plugin.PluginConfiguration;
import util.FileUtil;
import monogram.plugin.PluginManager;
import org.apache.log4j.*;

/**
 * @author University of Waikato - Te Whare Wānanga o Waikato
 * @version 1.0
 * @since   2014-11-20 
 */
public class FileUpload extends HttpServlet {

    private File tmpdir;
    private String inputFile;
    private String outputFile;

    //Create an instance of the Logger object created for this class in log4j.properties            
    static Logger logger = Logger.getLogger(web.servlets.DirectInput.class.getName());

    @Override
    public void init(ServletConfig config) throws ServletException {
        super.init(config);
        tmpdir = new File((String) config.getServletContext().getAttribute("tmpdir"));
    }

    protected void processRequest(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        //do nothing
    }

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        processRequest(request, response);
    }

    /** 
     * Handles the HTTP <code>POST</code> method.
     * @param request servlet request
     * @param response servlet response
     * @throws ServletException if a servlet-specific error occurs
     * @throws IOException if an I/O error occurs
     */
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        // set DI to false as this is not Directinput.
       DirectInput.DI = false; 
        final Properties properties = handleRequest(request);
        final String address = "/jsp" + (properties.getLanguage().equals("en") ? "/en" : "/mi");
        final PluginConfiguration configuration = configure(properties);
        final PluginManager pluginManager = new PluginManager(tmpdir);

        if (configuration.getFile().length() == 0) {
            configuration.getFile().delete();
            request.setAttribute("errorCode", "FILE_NOT_FOUND_ERROR");
            forward(address + "/error.jsp", request, response);
            return;
        }

        File restoredFile = null;
        try {
            restoredFile = pluginManager.run(configuration);
            request.setAttribute("file", restoredFile);
            request.setAttribute("fileType", configuration.getFileType());
            request.setAttribute("charsetEncoding", "utf-8");
            request.setAttribute("filename", properties.getFilename());
            request.setAttribute("preserveMacrons", properties.getPreserveExistingMacrons());
            request.setAttribute("options", properties.getOptions());
            forward(address + "/main.jsp", request, response);
        outputFile = stringFromFile(restoredFile);
        logger.error("Output:"+outputFile);
        } catch (UnsupportedOperationException e) {
            FileUtil.deleteFile(restoredFile);
            request.setAttribute("errorCode", "FILE_TYPE_NOT_SUPPORTED_ERROR");
            forward(address + "/error.jsp", request, response);
        } catch (Exception e) {
            FileUtil.deleteFile(restoredFile);
            request.setAttribute("errorCode", "UNEXPECTED_ERROR");
            forward(address + "/error.jsp", request, response);
        } finally {
            FileUtil.deleteFile(configuration.getFile());
        }
    }

    private void forward(String path, HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        final RequestDispatcher dispatcher = getServletContext().getRequestDispatcher(path);
        dispatcher.forward(request, response);
    }

    private Properties handleRequest(HttpServletRequest request) {
        Properties requestData = new Properties();
        DiskFileItemFactory factory = new DiskFileItemFactory();
        factory.setSizeThreshold(10 * 1024 * 1024);
        ServletFileUpload upload = new ServletFileUpload(factory);
        try {
            //System.out.println("looking at request parameters...");
            List<FileItem> items = upload.parseRequest(request);

            for (FileItem item : items) {
                if (item.isFormField()) {
                    String fieldName = item.getFieldName();
                    String fieldValue = item.getString();
                    if (fieldName.equals("charsetEncoding")) {
                        requestData.setCharsetEncoding(fieldValue);
                    } else if (fieldName.equals("fileType")) {
                        requestData.setFileType(fieldValue);
                    } else if (fieldName.equals("preserveExistingMacrons")) {
                        requestData.setPreserveExistingMacrons(fieldValue);
                    } else if (fieldName.equals("lang")) {
                        requestData.setLanguage(fieldValue);
                    } else if (fieldName.equals("options")) {
                        requestData.setOptions(fieldValue);
                    }
                } else {
                    String fileType = FileUtil.guessFileType(new File(item.getName()));
                    File file = File.createTempFile("mi-tmp-", fileType, tmpdir);
                    item.write(file);
                    requestData.setFile(file);
                    requestData.setFilename(item.getName());
            inputFile=stringFromFile(file);
            // logger.error("Input:"+logText);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return requestData;
    }
    
    private String stringFromFile(File file)throws IOException{
    BufferedReader reader = new BufferedReader(new FileReader(file));
    String line = null;
    StringBuilder sb = new StringBuilder();
    try{
        while((line=reader.readLine())!=null){
        sb.append(line);
        }
    }
    catch (Exception e){
        e.printStackTrace();
    }
    finally{
        reader.close();
    }
        return sb.toString();
    }
    
    private PluginConfiguration configure(Properties properties) {
        final File file = properties.getFile();
        final String fileType = properties.getFileType().equals("(detect automatically)") ? FileUtil.guessFileType(file) : properties.getFileType();
        final String charsetEncoding = properties.getCharsetEncoding().equals("(detect automatically)") ? "utf8" : properties.getCharsetEncoding();
        final String preserveExistingMacrons = properties.getPreserveExistingMacrons();

        final PluginConfiguration configuration = new PluginConfiguration();
        configuration.setFile(file);
        configuration.setFileType(fileType);
        configuration.setCharsetEncoding(charsetEncoding);
        configuration.setPreserveExistingMacrons(Boolean.getBoolean(preserveExistingMacrons));
        return configuration;
    }

    private class Properties {

        private File file;
        private String filename;
        private String fileType;
        private String charsetEncoding;
        private String preserveExistingMacrons;
        private String language;
        private String options;

        public File getFile() {
            return file;
        }

        public String getFilename() {
            return filename;
        }

        public String getFileType() {
            return fileType;
        }

        public String getCharsetEncoding() {
            return charsetEncoding;
        }

        public String getPreserveExistingMacrons() {
            return preserveExistingMacrons;
        }

        public String getLanguage() {
            return language;
        }

        public String getOptions() {
            return options;
        }

        public void setFile(File file) {
            this.file = file;
        }

        public void setFilename(String filename) {
            this.filename = filename;
        }

        public void setFileType(String fileType) {
            this.fileType = fileType;
        }

        public void setCharsetEncoding(String charsetEncoding) {
            this.charsetEncoding = charsetEncoding;
        }

        public void setPreserveExistingMacrons(String preserveExistingMacrons) {
            this.preserveExistingMacrons = preserveExistingMacrons;
        }

        public void setLanguage(String language) {
            this.language = language;
        }

        public void setOptions(String options) {
            this.options = options;
        }
    }
}