Example usage for org.apache.commons.fileupload.servlet ServletFileUpload isMultipartContent

List of usage examples for org.apache.commons.fileupload.servlet ServletFileUpload isMultipartContent

  1. HOME
  2. Java
  3. org.apache.commons
  4. org.apache.commons.fileupload.servlet.*
  5. ServletFileUpload
  6. isMultipartContent

Introduction

In this page you can find the example usage for org.apache.commons.fileupload.servlet ServletFileUpload isMultipartContent.

Prototype

public static final boolean isMultipartContent(HttpServletRequest request)

Source Link

Document

Utility method that determines whether the request contains multipart content.

Usage

From source file:graphql.servlet.GraphQLServlet.java

@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    GraphQLContext context = createContext(Optional.of(req), Optional.of(resp));
    InputStream inputStream = null;
    if (ServletFileUpload.isMultipartContent(req)) {
        ServletFileUpload upload = new ServletFileUpload();
        try {//from  w w w  .  j  a  v  a  2s . c  om
            FileItemIterator it = upload.getItemIterator(req);
            context.setFiles(Optional.of(it));
            while (inputStream == null && it.hasNext()) {
                FileItemStream stream = it.next();
                if (stream.getFieldName().contentEquals("graphql")) {
                    inputStream = stream.openStream();
                }
            }
            if (inputStream == null) {
                throw new ServletException("no query found");
            }
        } catch (FileUploadException e) {
            throw new ServletException("no query found");
        }
    } else {
        // this is not a multipart request
        inputStream = req.getInputStream();
    }
    Request request = new ObjectMapper().readValue(inputStream, Request.class);
    Map<String, Object> variables = request.variables;
    if (variables == null) {
        variables = new HashMap<>();
    }
    query(request.query, request.operationName, variables, getSchema(), req, resp, context);
}

From source file:com.openkm.servlet.admin.ConfigServlet.java

@Override
@SuppressWarnings("unchecked")
public void doPost(HttpServletRequest request, HttpServletResponse response)
        throws IOException, ServletException {
    log.debug("doPost({}, {})", request, response);
    request.setCharacterEncoding("UTF-8");
    ServletContext sc = getServletContext();
    String action = null;//ww w .  j  av  a  2  s. com
    String filter = "";
    String userId = request.getRemoteUser();
    Session dbSession = null;
    updateSessionManager(request);

    try {
        if (ServletFileUpload.isMultipartContent(request)) {
            InputStream is = null;
            FileItemFactory factory = new DiskFileItemFactory();
            ServletFileUpload upload = new ServletFileUpload(factory);
            List<FileItem> items = upload.parseRequest(request);
            ConfigStoredFile stFile = new ConfigStoredFile();
            Config cfg = new Config();
            byte data[] = null;

            for (Iterator<FileItem> it = items.iterator(); it.hasNext();) {
                FileItem item = it.next();

                if (item.isFormField()) {
                    if (item.getFieldName().equals("action")) {
                        action = item.getString("UTF-8");
                    } else if (item.getFieldName().equals("filter")) {
                        filter = item.getString("UTF-8");
                    } else if (item.getFieldName().equals("cfg_key")) {
                        cfg.setKey(item.getString("UTF-8"));
                    } else if (item.getFieldName().equals("cfg_type")) {
                        cfg.setType(item.getString("UTF-8"));
                    } else if (item.getFieldName().equals("cfg_value")) {
                        cfg.setValue(item.getString("UTF-8").trim());
                    }
                } else {
                    is = item.getInputStream();
                    stFile.setName(item.getName());
                    stFile.setMime(MimeTypeConfig.mimeTypes.getContentType(item.getName()));

                    if (cfg.getKey() != null && cfg.getKey().startsWith("logo")) {
                        String size = null;

                        if (cfg.getKey().equals(com.openkm.core.Config.PROPERTY_LOGO_LOGIN)) {
                            size = "316x74>";
                        } else if (cfg.getKey().equals(com.openkm.core.Config.PROPERTY_LOGO_REPORT)) {
                            size = "150x35>";
                        }

                        File tmpIn = FileUtils.createTempFileFromMime(stFile.getMime());
                        File tmpOut = FileUtils.createTempFileFromMime(stFile.getMime());
                        FileOutputStream fos = null;

                        try {
                            fos = new FileOutputStream(tmpIn);
                            IOUtils.copy(is, fos);
                            ImageUtils.resize(tmpIn, size, tmpOut);
                            data = FileUtils.readFileToByteArray(tmpOut);
                        } finally {
                            FileUtils.deleteQuietly(tmpIn);
                            FileUtils.deleteQuietly(tmpOut);
                            IOUtils.closeQuietly(fos);
                            IOUtils.closeQuietly(is);
                        }
                    } else {
                        data = IOUtils.toByteArray(is);
                        IOUtils.closeQuietly(is);
                    }

                    stFile.setContent(SecureStore.b64Encode(data));
                }
            }

            if (action.equals("create")) {
                if (Config.FILE.equals(cfg.getType())) {
                    cfg.setValue(new Gson().toJson(stFile));
                } else if (Config.BOOLEAN.equals(cfg.getType())) {
                    cfg.setValue(Boolean.toString(cfg.getValue() != null && !cfg.getValue().equals("")));
                } else if (Config.SELECT.equals(cfg.getType())) {
                    ConfigStoredSelect stSelect = ConfigDAO.getSelect(cfg.getKey());

                    if (stSelect != null) {
                        for (ConfigStoredOption stOption : stSelect.getOptions()) {
                            if (stOption.getValue().equals(cfg.getValue())) {
                                stOption.setSelected(true);
                            }
                        }
                    }

                    cfg.setValue(new Gson().toJson(stSelect));
                }

                ConfigDAO.create(cfg);
                com.openkm.core.Config.reload(sc, new Properties());

                // Activity log
                UserActivity.log(userId, "ADMIN_CONFIG_CREATE", cfg.getKey(), null, cfg.toString());
                list(userId, filter, request, response);
            } else if (action.equals("edit")) {
                if (Config.FILE.equals(cfg.getType())) {
                    cfg.setValue(new Gson().toJson(stFile));
                } else if (Config.BOOLEAN.equals(cfg.getType())) {
                    cfg.setValue(Boolean.toString(cfg.getValue() != null && !cfg.getValue().equals("")));
                } else if (Config.SELECT.equals(cfg.getType())) {
                    ConfigStoredSelect stSelect = ConfigDAO.getSelect(cfg.getKey());

                    if (stSelect != null) {
                        for (ConfigStoredOption stOption : stSelect.getOptions()) {
                            if (stOption.getValue().equals(cfg.getValue())) {
                                stOption.setSelected(true);
                            } else {
                                stOption.setSelected(false);
                            }
                        }
                    }

                    cfg.setValue(new Gson().toJson(stSelect));
                }

                ConfigDAO.update(cfg);
                com.openkm.core.Config.reload(sc, new Properties());

                // Activity log
                UserActivity.log(userId, "ADMIN_CONFIG_EDIT", cfg.getKey(), null, cfg.toString());
                list(userId, filter, request, response);
            } else if (action.equals("delete")) {
                ConfigDAO.delete(cfg.getKey());
                com.openkm.core.Config.reload(sc, new Properties());

                // Activity log
                UserActivity.log(userId, "ADMIN_CONFIG_DELETE", cfg.getKey(), null, null);
                list(userId, filter, request, response);
            } else if (action.equals("import")) {
                dbSession = HibernateUtil.getSessionFactory().openSession();
                importConfig(userId, request, response, data, dbSession);

                // Activity log
                UserActivity.log(request.getRemoteUser(), "ADMIN_CONFIG_IMPORT", null, null, null);
                list(userId, filter, request, response);
            }
        }
    } catch (DatabaseException e) {
        log.error(e.getMessage(), e);
        sendErrorRedirect(request, response, e);
    } catch (FileUploadException e) {
        log.error(e.getMessage(), e);
        sendErrorRedirect(request, response, e);
    } catch (SQLException e) {
        log.error(e.getMessage(), e);
        sendErrorRedirect(request, response, e);
    } finally {
        HibernateUtil.close(dbSession);
    }
}

From source file:eu.stratosphere.client.web.JobsServlet.java

@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    // check, if we are doing the right request
    if (!ServletFileUpload.isMultipartContent(req)) {
        resp.sendError(HttpServletResponse.SC_BAD_REQUEST);
        return;/*from  w w  w .j a v a  2 s.c  o m*/
    }

    // create the disk file factory, limiting the file size to 20 MB
    DiskFileItemFactory fileItemFactory = new DiskFileItemFactory();
    fileItemFactory.setSizeThreshold(20 * 1024 * 1024); // 20 MB
    fileItemFactory.setRepository(tmpDir);

    String filename = null;

    // parse the request
    ServletFileUpload uploadHandler = new ServletFileUpload(fileItemFactory);
    try {
        @SuppressWarnings("unchecked")
        Iterator<FileItem> itr = ((List<FileItem>) uploadHandler.parseRequest(req)).iterator();

        // go over the form fields and look for our file
        while (itr.hasNext()) {
            FileItem item = itr.next();
            if (!item.isFormField()) {
                if (item.getFieldName().equals("upload_jar_file")) {

                    // found the file, store it to the specified location
                    filename = item.getName();
                    File file = new File(destinationDir, filename);
                    item.write(file);
                    break;
                }
            }
        }
    } catch (FileUploadException ex) {
        resp.sendError(HttpServletResponse.SC_NOT_ACCEPTABLE, "Invalid Fileupload.");
        return;
    } catch (Exception ex) {
        resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
                "An unknown error occurred during the file upload.");
        return;
    }

    // write the okay message
    resp.sendRedirect(targetPage);
}

From source file:com.pdfhow.diff.UploadServlet.java

/**
 * Handles the HTTP <code>POST</code> method.
 *
 * @param request//from  w w w  .  ja va 2  s. com
 *            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 {
    if (!ServletFileUpload.isMultipartContent(request)) {
        throw new IllegalArgumentException(
                "Request is not multipart, please 'multipart/form-data' enctype for your form.");
    }

    ServletFileUpload uploadHandler = new ServletFileUpload(new DiskFileItemFactory());
    PrintWriter writer = response.getWriter();
    response.setContentType("application/json");
    JSONArray json = new JSONArray();
    try {
        List<FileItem> items = uploadHandler.parseRequest(request);
        for (FileItem item : items) {
            if (!item.isFormField()) {
                File file = new File(request.getServletContext().getRealPath("/") + "imgs/", item.getName());
                item.write(file);
                JSONObject jsono = new JSONObject();
                jsono.put("name", item.getName());
                jsono.put("size", item.getSize());
                jsono.put("url", "UploadServlet?getfile=" + item.getName());
                jsono.put("thumbnail_url", "UploadServlet?getthumb=" + item.getName());
                jsono.put("delete_url", "UploadServlet?delfile=" + item.getName());
                jsono.put("delete_type", "GET");
                json.put(jsono);
                System.out.println(json.toString());
            }
        }
    } catch (FileUploadException e) {
        throw new RuntimeException(e);
    } catch (Exception e) {
        throw new RuntimeException(e);
    } finally {
        writer.write(json.toString());
        writer.close();
    }
}

From source file:net.morphbank.mbsvc3.webservices.RestService.java

protected void doPost(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    if (!isIPAllowed(request.getRemoteAddr())) {
        response.sendError(HttpServletResponse.SC_FORBIDDEN,
                "This IP is not allowed. Current IP used:" + request.getRemoteAddr());
        return;// w  w  w  . j a va  2 s .c  o m
    }
    PrintWriter out = response.getWriter();
    MorphbankConfig.SYSTEM_LOGGER.info("starting post from ip:" + request.getRemoteAddr());
    MorphbankConfig.ensureWorkingConnection();
    response.setContentType("text/xml");
    MorphbankConfig.SYSTEM_LOGGER.info("<!-- persistence: " + MorphbankConfig.getPersistenceUnit() + " -->");
    MorphbankConfig.SYSTEM_LOGGER.info("<!-- filepath: " + folderPath + " -->");
    boolean isMultipart = ServletFileUpload.isMultipartContent(request);

    FileItemFactory factory = new DiskFileItemFactory();
    ServletFileUpload upload = new ServletFileUpload(factory);
    //      response.setContentType("text/html");

    String parameter = request.getParameter("uploadxml");
    if (parameter != null) {
        ServletContext context = getServletContext();
        InputStream fis = context.getResourceAsStream(parameter);
        processRequest(fis, out, request.getParameter("fileName"));
    } else {
        try {
            // Process the uploaded items
            List<?> /* FileItem */ items = upload.parseRequest(request);
            Iterator<?> iter = items.iterator();
            while (iter.hasNext()) {
                FileItem item = (FileItem) iter.next();

                if (item.isFormField()) {
                    // processFormField(item);
                } else {
                    // processUploadedFile(item);
                    String paramName = item.getFieldName();
                    String fileName = item.getName();
                    InputStream stream = item.getInputStream();
                    MorphbankConfig.SYSTEM_LOGGER.info("Processing file " + fileName);
                    processRequest(stream, out, fileName);
                    MorphbankConfig.SYSTEM_LOGGER.info("Processing complete");
                }
            }
        } catch (FileUploadException e) {
            e.printStackTrace();
        }
    }
}

From source file:it.unipmn.di.dcs.sharegrid.web.servlet.MultipartFilter.java

public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
        throws IOException, ServletException {
    if (request.getAttribute(MultipartFilter.DoFilterCalledAttr) != null) {
        chain.doFilter(request, response);
        return;/*from  w  w w.ja  v  a 2s  .  c  o m*/
    }

    request.setAttribute(MultipartFilter.DoFilterCalledAttr, "true");

    // sanity check
    if (!(response instanceof HttpServletResponse)) {
        chain.doFilter(request, response);
        return;
    }

    HttpServletRequest httpReq = (HttpServletRequest) request;

    if (!ServletFileUpload.isMultipartContent(httpReq)) {
        chain.doFilter(request, response);
        return;
    }

    // Wraps the current request into a multipart request object
    // for handling multipart form parameters.

    MultipartRequestWrapper reqWrapper = null;

    reqWrapper = new MultipartRequestWrapper(httpReq, this.maxSize, this.maxFileSize, this.thresholdSize,
            this.repositoryPath);

    chain.doFilter(reqWrapper, response);
}

From source file:net.openkoncept.vroom.VroomController.java

/**
 * <p> This method analyzes the request and delegate control to other
 * methods for processing. </p>/*w  w w  . ja v a  2  s. c  om*/
 *
 * @param request - HttpServletRequest
 * @param response - HttpServletResponse
 * @throws ServletException - ServletException
 * @throws IOException - IOException
 */
protected void processRequest(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {

    String contextPath = request.getContextPath();
    String servletPath = request.getServletPath();
    String sessionId = request.getSession().getId();
    String requestPath = contextPath + servletPath + ";" + SESSION_ID + "=" + sessionId;
    String uri = request.getParameter(GENERATE_URI);
    String rt = request.getParameter(RT);
    String method = request.getParameter(METHOD);

    List parts = null;
    Map paramMap = null;
    if (ServletFileUpload.isMultipartContent(request)) {
        paramMap = new HashMap();
        DiskFileItemFactory factory = new DiskFileItemFactory(fileUploadSizeThreshold, fileUploadTempFolder);
        ServletFileUpload sfu = new ServletFileUpload(factory);
        try {
            parts = sfu.parseRequest(request);
            Iterator iter = parts.iterator();
            while (iter.hasNext()) {
                FileItem fi = (FileItem) iter.next();
                //                    if(fi.isFormField()) {
                //                        List l = (List) paramMap.get(fi.getFieldName());
                //                        if(l == null) {
                //                            l = new ArrayList();
                //                            paramMap.put(fi.getFieldName(), l);
                //                        }
                //                        l.add(fi.getString());
                //                    } else {
                //                        paramMap.put(fi.getFieldName(), fi);
                //                    }
                List l = (List) paramMap.get(fi.getFieldName());
                if (l == null) {
                    l = new ArrayList();
                    paramMap.put(fi.getFieldName(), l);
                }
                if (fi.isFormField()) {
                    l.add(fi.getString());
                } else {
                    l.add(fi);
                }
            }
        } catch (FileUploadException e) {
            throw new ServletException("Unable to part multipart/form-data", e);
        }
        if (parts != null) {
            rt = (String) ((ArrayList) paramMap.get(RT)).get(0);
            method = (String) ((ArrayList) paramMap.get(METHOD)).get(0);
        }
    }

    if (RT_JS.equals(rt)) {
        if (METHOD_FILE.equals(method)) {
            processRequestJSFile(request, response, contextPath, servletPath, sessionId, requestPath);
        } else if (METHOD_GENERATE.equals(method)) {
            processRequestJSGenerate(request, response, contextPath, servletPath, sessionId, uri);
        }
    } else if (RT_INVOKE.equals(rt)) {
        processRequestInvoke(request, response);
    } else if (RT_SUBMIT.equals(rt)) {
        processRequestSubmit(request, response, paramMap);
    }
}

From source file:com.nemesis.admin.UploadServlet.java

/**
 * @param request/*from   ww  w. j  a  v  a  2  s  .com*/
 * @param response
 * @throws javax.servlet.ServletException
 * @throws java.io.IOException
 * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse
 * response)
 *
 */
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    if (!ServletFileUpload.isMultipartContent(request)) {
        throw new IllegalArgumentException(
                "Request is not multipart, please 'multipart/form-data' enctype for your form.");
    }

    ServletFileUpload uploadHandler = new ServletFileUpload(new DiskFileItemFactory());
    PrintWriter writer = response.getWriter();
    response.setContentType("application/json");
    JsonArray json = new JsonArray();
    try {
        List<FileItem> items = uploadHandler.parseRequest(request);
        for (FileItem item : items) {
            if (!item.isFormField()) {
                final String savedFile = UUID.randomUUID().toString() + "." + getSuffix(item.getName());
                File file = new File(request.getServletContext().getRealPath("/") + "uploads/", savedFile);
                item.write(file);
                JsonObject jsono = new JsonObject();
                jsono.addProperty("name", savedFile);
                jsono.addProperty("path", file.getAbsolutePath());
                jsono.addProperty("size", item.getSize());
                json.add(jsono);
                System.out.println(json.toString());
            }
        }
    } catch (FileUploadException e) {
        throw new RuntimeException(e);
    } catch (Exception e) {
        throw new RuntimeException(e);
    } finally {
        writer.write(json.toString());
        writer.close();
    }

}

From source file:com.sonicle.webtop.core.app.AbstractEnvironmentService.java

public void processUpload(HttpServletRequest request, HttpServletResponse response, PrintWriter out) {
    ServletFileUpload upload = null;/*  w  w w  . j av a  2s  .c  o m*/
    WebTopSession.UploadedFile uploadedFile = null;
    HashMap<String, String> multipartParams = new HashMap<>();

    try {
        String service = ServletUtils.getStringParameter(request, "service", true);
        String cntx = ServletUtils.getStringParameter(request, "context", true);
        String tag = ServletUtils.getStringParameter(request, "tag", null);
        if (!ServletFileUpload.isMultipartContent(request))
            throw new Exception("No upload request");

        IServiceUploadStreamListener istream = getUploadStreamListener(cntx);
        if (istream != null) {
            try {
                MapItem data = new MapItem(); // Empty response data

                // Defines the upload object
                upload = new ServletFileUpload();
                FileItemIterator it = upload.getItemIterator(request);
                while (it.hasNext()) {
                    FileItemStream fis = it.next();
                    if (fis.isFormField()) {
                        InputStream is = null;
                        try {
                            is = fis.openStream();
                            String key = fis.getFieldName();
                            String value = IOUtils.toString(is, "UTF-8");
                            multipartParams.put(key, value);
                        } finally {
                            IOUtils.closeQuietly(is);
                        }
                    } else {
                        // Creates uploaded object
                        uploadedFile = new WebTopSession.UploadedFile(true, service, IdentifierUtils.getUUID(),
                                tag, fis.getName(), -1, findMediaType(fis));

                        // Fill response data
                        data.add("virtual", uploadedFile.isVirtual());
                        data.add("editable", isFileEditableInDocEditor(fis.getName()));

                        // Handle listener, its implementation can stop
                        // file upload throwing a UploadException.
                        InputStream is = null;
                        try {
                            getEnv().getSession().addUploadedFile(uploadedFile);
                            is = fis.openStream();
                            istream.onUpload(cntx, request, multipartParams, uploadedFile, is, data);
                        } finally {
                            IOUtils.closeQuietly(is);
                            getEnv().getSession().removeUploadedFile(uploadedFile, false);
                        }
                    }
                }
                new JsonResult(data).printTo(out);

            } catch (UploadException ex1) {
                new JsonResult(false, ex1.getMessage()).printTo(out);
            } catch (Exception ex1) {
                throw ex1;
            }

        } else {
            try {
                MapItem data = new MapItem(); // Empty response data
                IServiceUploadListener iupload = getUploadListener(cntx);

                // Defines the upload object
                DiskFileItemFactory factory = new DiskFileItemFactory();
                //TODO: valutare come imporre i limiti
                //factory.setSizeThreshold(yourMaxMemorySize);
                //factory.setRepository(yourTempDirectory);
                upload = new ServletFileUpload(factory);
                List<FileItem> files = upload.parseRequest(request);

                // Plupload component (client-side) will upload multiple file 
                // each in its own request. So we can skip loop on files.
                Iterator it = files.iterator();
                while (it.hasNext()) {
                    FileItem fi = (FileItem) it.next();
                    if (fi.isFormField()) {
                        InputStream is = null;
                        try {
                            is = fi.getInputStream();
                            String key = fi.getFieldName();
                            String value = IOUtils.toString(is, "UTF-8");
                            multipartParams.put(key, value);
                        } finally {
                            IOUtils.closeQuietly(is);
                        }
                    } else {
                        // Writes content into a temp file
                        File file = WT.createTempFile(UPLOAD_TEMPFILE_PREFIX);
                        fi.write(file);

                        // Creates uploaded object
                        uploadedFile = new WebTopSession.UploadedFile(false, service, file.getName(), tag,
                                fi.getName(), fi.getSize(), findMediaType(fi));
                        getEnv().getSession().addUploadedFile(uploadedFile);

                        // Fill response data
                        data.add("virtual", uploadedFile.isVirtual());
                        data.add("uploadId", uploadedFile.getUploadId());
                        data.add("editable", isFileEditableInDocEditor(fi.getName()));

                        // Handle listener (if present), its implementation can stop
                        // file upload throwing a UploadException.
                        if (iupload != null) {
                            try {
                                iupload.onUpload(cntx, request, multipartParams, uploadedFile, data);
                            } catch (UploadException ex2) {
                                getEnv().getSession().removeUploadedFile(uploadedFile, true);
                                throw ex2;
                            }
                        }
                    }
                }
                new JsonResult(data).printTo(out);

            } catch (UploadException ex1) {
                new JsonResult(ex1).printTo(out);
            }
        }

    } catch (Exception ex) {
        WebTopApp.logger.error("Error uploading", ex);
        new JsonResult(ex).printTo(out);
    }
}

From source file:kotys.monika.MenuCreatorJSP.LoadData.java

/**
 * Handles the HTTP <code>POST</code> method.
 *
 * @param request servlet request/*w w w . j av  a2 s .c o m*/
 * @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 {
    // Check that we have a file upload request
    request.setCharacterEncoding("UTF-8");
    boolean isMultipart = ServletFileUpload.isMultipartContent(request);
    ArrayList<String> files = new ArrayList<String>();

    if (!isMultipart) {
        return;
    }

    // Create a factory for disk-based file items
    DiskFileItemFactory factory = new DiskFileItemFactory();

    // Sets the size threshold beyond which files are written directly to
    // disk.
    factory.setSizeThreshold(MAX_MEMORY_SIZE);

    // Sets the directory used to temporarily store files that are larger
    // than the configured size threshold. We use temporary directory for
    // java
    factory.setRepository(new File(System.getProperty("java.io.tmpdir")));

    // constructs the folder where uploaded file will be stored
    String uploadFolder = getServletContext().getRealPath("") + File.separator + DATA_DIRECTORY;

    // Create a new file upload handler
    ServletFileUpload upload = new ServletFileUpload(factory);

    // Set overall request size constraint
    upload.setSizeMax(MAX_REQUEST_SIZE);

    try {
        // Parse the request
        List items = upload.parseRequest(request);
        Iterator iter = items.iterator();
        while (iter.hasNext()) {
            FileItem item = (FileItem) iter.next();

            if (!item.isFormField()) {
                String fileName = new File(item.getName()).getName();
                String filePath = uploadFolder + File.separator + fileName;
                File uploadedFile = new File(filePath);
                System.out.println(filePath);
                // saves the file to upload directory
                item.write(uploadedFile);
                files.add(filePath);
            }
        }

        // displays done.jsp page after upload finished
        request.getSession().setAttribute("uploadedFiles", files);
        processRequest(request, response);

    } catch (FileUploadException ex) {
        throw new ServletException(ex);
    } catch (Exception ex) {
        Logger.getLogger(LoadData.class.getName()).log(Level.SEVERE, null, ex);
    }

}