org.hdiv.config.multipart.StrutsMultipartConfig.java Source code

Introduction

Here is the source code for org.hdiv.config.multipart.StrutsMultipartConfig.java

Source

/**
 * Copyright 2005-2013 hdiv.org
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.hdiv.config.multipart;

import java.util.Iterator;
import java.util.List;

import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;

import org.apache.commons.fileupload.DiskFileUpload;
import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileUploadException;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hdiv.config.multipart.exception.HdivMultipartException;
import org.hdiv.filter.RequestWrapper;

/**
 * Class containing multipart request configuration and methods initialized from Spring Factory.
 * 
 * @author Gorka Vicente
 */
public class StrutsMultipartConfig extends AbstractMultipartConfig {

    /**
     * Commons Logging instance.
     */
    private static Log log = LogFactory.getLog(StrutsMultipartConfig.class);

    /**
     * The size threshold which determines whether an uploaded file will be written to disk or cached in memory.
     */
    protected String memFileSize;

    /**
     * Parses the input stream and partitions the parsed items into a set of form fields and a set of file items.
     * 
     * @param request
     *            The multipart request wrapper.
     * @param servletContext
     *            Our ServletContext object
     * @return multipart processed request
     * @throws HdivMultipartException
     *             if an unrecoverable error occurs.
     */
    public HttpServletRequest handleMultipartRequest(RequestWrapper request, ServletContext servletContext)
            throws HdivMultipartException {

        DiskFileUpload upload = new DiskFileUpload();

        upload.setHeaderEncoding(request.getCharacterEncoding());
        // Set the maximum size before a FileUploadException will be thrown.
        upload.setSizeMax(getSizeMax());
        // Set the maximum size that will be stored in memory.
        upload.setSizeThreshold((int) getSizeThreshold());
        // Set the the location for saving data on disk.
        upload.setRepositoryPath(getRepositoryPath(servletContext));

        List<FileItem> items = null;
        try {
            items = upload.parseRequest(request);

        } catch (DiskFileUpload.SizeLimitExceededException e) {
            if (log.isErrorEnabled()) {
                log.error("Size limit exceeded exception");
            }
            // Special handling for uploads that are too big.
            throw new HdivMultipartException(e);

        } catch (FileUploadException e) {
            if (log.isErrorEnabled()) {
                log.error("Failed to parse multipart request", e);
            }
            throw new HdivMultipartException(e);
        }

        // Process the uploaded items
        Iterator<FileItem> iter = items.iterator();
        while (iter.hasNext()) {
            FileItem item = iter.next();

            if (item.isFormField()) {
                this.addTextParameter(request, item);
            } else {
                this.addFileParameter(request, item);
            }
        }
        return request;
    }

    /**
     * Returns the size threshold which determines whether an uploaded file will be written to disk or cached in memory.
     * 
     * @return The size threshold, in bytes.
     */
    protected long getSizeThreshold() {
        return convertSizeToBytes(this.memFileSize, AbstractMultipartConfig.DEFAULT_SIZE_THRESHOLD);
    }

    /**
     * Adds a regular text parameter to the set of text parameters for this request. Handles the case of multiple values
     * for the same parameter by using an array for the parameter value.
     * 
     * @param request
     *            The request in which the parameter was specified.
     * @param item
     *            The file item for the parameter to add.
     */
    public void addTextParameter(RequestWrapper request, FileItem item) {

        String name = item.getFieldName();
        String value = null;
        boolean haveValue = false;
        String encoding = request.getCharacterEncoding();

        if (encoding != null) {
            try {
                value = item.getString(encoding);
                haveValue = true;
            } catch (Exception e) {
                // Handled below, since haveValue is false.
            }
        }
        if (!haveValue) {
            try {
                value = item.getString("ISO-8859-1");
            } catch (java.io.UnsupportedEncodingException uee) {
                value = item.getString();
            }
            haveValue = true;
        }

        String[] oldArray = (String[]) request.getParameterValues(name);
        String[] newArray;

        if (oldArray != null) {
            newArray = new String[oldArray.length + 1];
            System.arraycopy(oldArray, 0, newArray, 0, oldArray.length);
            newArray[oldArray.length] = value;
        } else {
            newArray = new String[] { value };
        }

        request.addParameter(name, newArray);
    }

    public void cleanupMultipart(HttpServletRequest request) {
    }

    /**
     * @param memFileSize
     *            The memFileSize to set.
     */
    public void setMemFileSize(String memFileSize) {
        this.memFileSize = memFileSize;
    }
}