Example usage for org.apache.commons.fileupload FileUploadException printStackTrace

List of usage examples for org.apache.commons.fileupload FileUploadException printStackTrace

Introduction

In this page you can find the example usage for org.apache.commons.fileupload FileUploadException printStackTrace.

Prototype

public void printStackTrace() 

Source Link

Document

Prints this throwable and its backtrace to the standard error stream.

Usage

From source file:org.jxstar.control.action.ActionHelper.java

/**
 * ?//  w ww . j  ava  2s.  c o  m
 * @param request
 * @return
 */
private static Map<String, Object> parseMultiRequest(HttpServletRequest request) throws ActionException {
    //?
    DefaultFileItemFactory factory = new DefaultFileItemFactory();
    //?
    DiskFileUpload upload = new DiskFileUpload(factory);
    //????
    upload.setHeaderEncoding("utf-8");
    //?10M
    String maxSize = SystemVar.getValue("upload.file.maxsize", "10");
    upload.setSizeMax(1000 * 1000 * Integer.parseInt(maxSize));
    //?
    List<FileItem> items = null;
    try {
        items = upload.parseRequest(request);
    } catch (FileUploadException e) {
        _log.showError(e);
        throw new ActionException(JsMessage.getValue("fileaction.overmaxsize"), maxSize);
    }
    _log.showDebug("request item size=" + items.size());

    //
    Map<String, Object> requestMap = FactoryUtil.newMap();
    // ?
    Iterator<FileItem> iter = items.iterator();
    while (iter.hasNext()) {
        FileItem item = iter.next();
        if (item.isFormField()) {
            String key = item.getFieldName();
            //?????
            String value = "";
            try {
                value = item.getString("utf-8");
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
            if (key == null || key.length() == 0)
                continue;
            requestMap.put(key, value);
        } else {
            String key = item.getFieldName();
            requestMap.put(key, item);
            //??
            String fileName = item.getName();
            String contentType = item.getContentType();
            long fileSize = item.getSize();
            _log.showDebug(
                    "request filename=" + fileName + ";fileSize=" + fileSize + ";contentType=" + contentType);
        }
    }

    return requestMap;
}

From source file:org.kie.jbpm.designer.server.StencilSetExtensionGeneratorServlet.java

/**
 * Request parameters are documented in//  w  w w  .  j a  va 2 s.  c o  m
 * editor/test/examples/stencilset-extension-generator.xhtml
 * The parameter 'csvFile' is always required.
 * An example CSV file can be found in
 * editor/test/examples/design-thinking-example-data.csv
 * which has been exported using OpenOffice.org from
 * editor/test/examples/design-thinking-example-data.ods
 */
protected void doPost(HttpServletRequest request, HttpServletResponse response) {
    this.request = request;
    this.response = response;
    this.baseUrl = Repository.getBaseUrl(request);
    this.repository = new Repository(baseUrl);

    // parameters and their default values
    String modelNamePrefix = "Generated Model using ";
    String stencilSetExtensionNamePrefix = StencilSetExtensionGenerator.DEFAULT_STENCIL_SET_EXTENSION_NAME_PREFIX;
    String baseStencilSetPath = StencilSetExtensionGenerator.DEFAULT_BASE_STENCIL_SET_PATH;
    String baseStencilSet = StencilSetExtensionGenerator.DEFAULT_BASE_STENCIL_SET;
    String baseStencil = StencilSetExtensionGenerator.DEFAULT_BASE_STENCIL;
    List<String> stencilSetExtensionUrls = new ArrayList<String>();
    String[] columnPropertyMapping = null;
    String[] csvHeader = null;
    List<Map<String, String>> stencilPropertyMatrix = new ArrayList<Map<String, String>>();
    String modelDescription = "The initial version of this model has been created by the Stencilset Extension Generator.";
    String additionalERDFContentForGeneratedModel = "";
    String[] modelTags = null;

    // Check that we have a file upload request
    boolean isMultipart = ServletFileUpload.isMultipartContent(request);

    if (isMultipart) {

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

        // Parse the request
        FileItemIterator iterator;
        try {
            iterator = upload.getItemIterator(request);
            while (iterator.hasNext()) {
                FileItemStream item = iterator.next();
                String name = item.getFieldName();
                InputStream stream = item.openStream();
                if (item.isFormField()) {
                    // ordinary form field
                    String value = Streams.asString(stream);
                    //System.out.println("Form field " + name + " with value "
                    //    + value + " detected.");
                    if (name.equals("modelNamePrefix")) {
                        modelNamePrefix = value;
                    } else if (name.equals("stencilSetExtensionNamePrefix")) {
                        stencilSetExtensionNamePrefix = value;
                    } else if (name.equals("baseStencilSetPath")) {
                        baseStencilSetPath = value;
                    } else if (name.equals("baseStencilSet")) {
                        baseStencilSet = value;
                    } else if (name.equals("stencilSetExtension")) {
                        stencilSetExtensionUrls.add(value);
                    } else if (name.equals("baseStencil")) {
                        baseStencil = value;
                    } else if (name.equals("columnPropertyMapping")) {
                        columnPropertyMapping = value.split(",");
                    } else if (name.equals("modelDescription")) {
                        modelDescription = value;
                    } else if (name.equals("modelTags")) {
                        modelTags = value.split(",");
                    } else if (name.equals("additionalERDFContentForGeneratedModel")) {
                        additionalERDFContentForGeneratedModel = value;
                    }
                } else {
                    // file field
                    //System.out.println("File field " + name + " with file name "
                    //    + item.getName() + " detected.");
                    // Process the input stream
                    if (name.equals("csvFile")) {
                        CsvMapReader csvFileReader = new CsvMapReader(new InputStreamReader(stream, "UTF-8"),
                                CsvPreference.EXCEL_PREFERENCE);
                        csvHeader = csvFileReader.getCSVHeader(true);
                        if (columnPropertyMapping != null || columnPropertyMapping.length > 0) {
                            csvHeader = columnPropertyMapping;
                        }
                        Map<String, String> row;
                        while ((row = csvFileReader.read(csvHeader)) != null) {
                            stencilPropertyMatrix.add(row);
                        }
                    }
                }
            }

            // generate stencil set
            Date creationDate = new Date(System.currentTimeMillis());
            DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH-mm-ss.SSS");
            String stencilSetExtensionName = stencilSetExtensionNamePrefix + " "
                    + dateFormat.format(creationDate);

            stencilSetExtensionUrls
                    .add(StencilSetExtensionGenerator.generateStencilSetExtension(stencilSetExtensionName,
                            stencilPropertyMatrix, columnPropertyMapping, baseStencilSet, baseStencil));

            // generate new model
            String modelName = modelNamePrefix + stencilSetExtensionName;
            String model = repository.generateERDF(UUID.randomUUID().toString(),
                    additionalERDFContentForGeneratedModel, baseStencilSetPath, baseStencilSet,
                    stencilSetExtensionUrls, modelName, modelDescription);
            String modelUrl = baseUrl + repository.saveNewModel(model, modelName, modelDescription,
                    baseStencilSet, baseStencilSetPath);

            // hack for reverse proxies:
            modelUrl = modelUrl.substring(modelUrl.lastIndexOf("http://"));

            // tag model
            if (modelTags != null) {
                for (String tagName : modelTags) {
                    repository.addTag(modelUrl, tagName.trim());
                }
            }

            // redirect client to editor with that newly generated model
            response.setHeader("Location", modelUrl);
            response.setStatus(HttpServletResponse.SC_MOVED_PERMANENTLY);

        } catch (FileUploadException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    } else {
        // TODO Add some error message
    }
}

From source file:org.lainsoft.forge.flow.helper.GenericViewHelper.java

public Map track_parameters() {
    if (params == null || params.isEmpty()) {
        params = new TreeMap();
        params.put("request_params", request.getParameterMap());
        params.put("mime_params", new TreeMap());
        ServletFileUpload upload = new ServletFileUpload(new DiskFileItemFactory());
        if (upload.isMultipartContent(new ServletRequestContext(request))) {
            System.out.println("FILEUPLOAD>Parsing params");

            List items = new ArrayList();
            try {
                items = upload.parseRequest(request);
            } catch (FileUploadException fue) {
                System.out.println("Couldn't parse request>" + fue);
                fue.printStackTrace();
            }/*from  w  w w .  j a va2  s .com*/
            Map tracked_req_params = new TreeMap();
            Map tracked_mime_params = new TreeMap();
            for (int i = 0; i < items.size(); i++) {
                FileItem item = (FileItem) items.get(i);
                if (item.isFormField()) {
                    tracked_req_params.put(item.getFieldName(), item.getString());
                } else {
                    tracked_mime_params.put(item.getFieldName(), item);
                }
            }
            params.put("request_params", tracked_req_params);
            params.put("mime_params", tracked_mime_params);
        }
    }
    return params;
}

From source file:org.mifos.dmt.ui.DMTExcelUpload.java

@SuppressWarnings("rawtypes")
protected void doPost(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    DMTLock migrationLock = DMTLock.getInstance();
    if (!migrationLock.isLocked()) {
        migrationLock.getLock();/*from ww w. ja va  2s  .c  o m*/

        clearLogs();
        response.setContentType("text/plain");

        DiskFileItemFactory fileItemFactory = new DiskFileItemFactory();
        fileItemFactory.setSizeThreshold(5 * 1024 * 1024);
        fileItemFactory.setRepository(tmpDir);
        ServletFileUpload uploadHandler = new ServletFileUpload(fileItemFactory);

        try {
            List items = uploadHandler.parseRequest(request);
            Iterator itr = items.iterator();
            while (itr.hasNext()) {
                FileItem item = (FileItem) itr.next();

                File file = new File(destinationDir, "MigrationTemplate.xlsx");
                /*System.out.println("i got here " + destinationDir.toString());*/
                Workbook workbook = WorkbookFactory.create(item.getInputStream());

                SheetStructure sheetStructure = new SheetStructure(workbook);
                if (!sheetStructure.processWorkbook()) {
                    logger.error(
                            "Excel upload failed!!Please check if necessary sheets are present in the excel");
                    throw new DMTException(
                            "Excel upload failed!!Please check if necessary sheets are present in the excel");
                }

                String baseTemplate = DMTConfig.DMT_CONFIG_DIR + "\\DMTMigrationTemplateBase.xlsx";
                ColumnStructure columnstructure = new ColumnStructure(workbook, baseTemplate);
                workbook = columnstructure.processSheetStructure();

                PurgeEmptyRows excessrows = new PurgeEmptyRows(workbook);
                workbook = excessrows.processEmptyRows();

                FileOutputStream fileoutputstream = new FileOutputStream(file);
                workbook.write(fileoutputstream);
                logger.info("Uploading of Excel has been successful!!");
                migrationLock.releaseLock();
            }
        } catch (FileUploadException ex) {
            logger.error("Error encountered while parsing the request", ex);
            logger.error("Uploading of Excel has not been successful!!");
            migrationLock.releaseLock();
            ex.printStackTrace();
        } catch (Exception ex) {
            logger.error("Error encountered while uploading file", ex);
            logger.error("Uploading of Excel has not been successful!!");
            migrationLock.releaseLock();
            ex.printStackTrace();
        }

    } else {
        request.setAttribute("action", "info");
        RequestDispatcher requestDispatcher = getServletContext().getRequestDispatcher("/x");
        requestDispatcher.forward(request, response);
    }
}

From source file:org.mortbay.servlet.LLabsMultiPartFilter.java

/**
 * @see javax.servlet.Filter#doFilter(javax.servlet.ServletRequest,
 *      javax.servlet.ServletResponse, javax.servlet.FilterChain)
 *//*from  w w  w .  j a va 2s.  co m*/
@SuppressWarnings("unchecked")
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
        throws IOException, ServletException {

    logger.info("Received uploadRequest:" + request);
    if (Log.isDebugEnabled())
        Log.debug(getClass().getName() + ">>> Received Request");

    HttpServletRequest srequest = (HttpServletRequest) request;
    if (srequest.getContentType() == null || !srequest.getContentType().startsWith("multipart/form-data")) {
        chain.doFilter(request, response);
        return;
    }
    if (ServletFileUpload.isMultipartContent(srequest)) {
        // Parse the request

        List<File> tempFiles = new ArrayList<File>();
        try {

            MultiMap params = new MultiMap();

            logger.info("Parsing Request");

            List<DiskFileItem> fileItems = uploadHandler.parseRequest(srequest);

            logger.info("Done Parsing Request, got FileItems:" + fileItems);

            StringBuilder filenames = new StringBuilder();

            for (final DiskFileItem diskFileItem : fileItems) {
                if (diskFileItem.getName() == null && diskFileItem.getFieldName() != null
                        && diskFileItem.getFieldName().length() > 0) {
                    params.put(diskFileItem.getFieldName(), diskFileItem.getString());
                    continue;
                }
                if (diskFileItem.getName() == null)
                    continue;
                final File tempFile = File.createTempFile("upload" + diskFileItem.getName(), ".tmp");
                tempFiles.add(tempFile);

                diskFileItem.write(tempFile);
                request.setAttribute(diskFileItem.getName(), tempFile);
                filenames.append(diskFileItem.getName()).append(",");
            }
            params.put("Filenames", filenames.toString());
            logger.info("passing on filter");
            chain.doFilter(new Wrapper(srequest, params), response);

            for (final DiskFileItem diskFileItem : fileItems) {
                diskFileItem.delete();
            }
        } catch (FileUploadException e) {
            e.printStackTrace();
            Log.warn(getClass().getName() + "MPartRequest, ERROR:" + e.getMessage());
            logger.error("FileUpload Failed", e);
            writeResponse((HttpServletResponse) response, HttpServletResponse.SC_EXPECTATION_FAILED);
        } catch (Throwable e) {
            logger.error(e.getMessage(), e);
            Log.warn(getClass().getName() + "MPartRequest, ERROR:" + e.getMessage());
            e.printStackTrace();
            writeResponse((HttpServletResponse) response, HttpServletResponse.SC_EXPECTATION_FAILED);
        } finally {
            for (File tempFile : tempFiles) {
                try {
                    tempFile.delete();
                } catch (Throwable t) {
                }
            }
        }
    }

}

From source file:org.ned.server.nedadminconsole.server.NedFileUploadServlet.java

@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

    resp.setContentType("text/html");
    boolean isMultipart = ServletFileUpload.isMultipartContent(req);
    if (!isMultipart) {
        resp.setStatus(HttpServletResponse.SC_BAD_REQUEST);
        resp.getWriter().print(NedServerResponses.ERROR_MULTIPART_CONTENT);
        resp.flushBuffer();/* w  w w .  j a  v a  2  s  .c o  m*/
        return; // send response
    }

    FileItemFactory factory = new DiskFileItemFactory();
    List<?> items = null;
    Iterator<?> iter = null;
    FileItem item = null;
    String name = null;
    String libraryId = null;
    String contentId = null;
    String file = null;
    String contentType = null;
    File uploadedFile = null;

    ServletFileUpload upload = new ServletFileUpload(factory);
    try {
        items = upload.parseRequest(req);
    } catch (FileUploadException ex) {
        ex.printStackTrace();
    }

    // now the downloading begins
    if (items == null) {
        resp.setStatus(HttpServletResponse.SC_BAD_REQUEST);
        resp.getWriter().print(NedServerResponses.ERROR_BAD_REQUEST);
        resp.flushBuffer();
        return;
    }

    // first get only parameters
    iter = items.iterator();
    while (iter.hasNext()) {
        item = (FileItem) iter.next();

        if (item.getFieldName().equals("libId")) {
            libraryId = item.getString();
        } else if (item.getFieldName().equals("contentId")) {
            contentId = item.getString();
        } else if (item.getFieldName().equals("languageName")) {
            processUploadNewLanguage(items, resp);
            return;
        }
    }
    iter = items.iterator();
    while (iter.hasNext()) {
        item = (FileItem) iter.next();
        if (!item.isFormField()) {
            name = item.getName();
            int slashindex = name.lastIndexOf('\\');
            if (slashindex > -1) {
                file = name.substring(slashindex + 1, name.length());
            } else {
                file = name.substring(name.lastIndexOf('/') + 1, name.length());
            }

            contentType = getMediaType(name);
            if (contentType == null || contentType.isEmpty()) {
                resp.setStatus(HttpServletResponse.SC_FORBIDDEN);
                resp.getWriter().print(NedServerResponses.ERROR_WRONG_FILE_TYPE);
                resp.flushBuffer();
                disconnectPostgres();
                return;
            }

            // FILE PATH CONSISTS OF
            // ROOT - TOMCAT_PATH\webapps\ROOT
            // BASEROOT - PASSED FROM CLIENT - librartId(signifies the catalogue instance)
            // nokiaecd\videos
            // FILENAME - GET FROM CHOSEN FILE

            String directory = createDirectory(libraryId);

            File fDir = new File(directory);
            fDir.getAbsolutePath();
            if (!fDir.exists()) {
                fDir.mkdirs();
            }

            file = createFilePath(directory, file);
            String uf = directory + file;
            uploadedFile = new File(uf);

            // //////////////////////////////////////////////
            InputStream uploadedStream = item.getInputStream();
            FileOutputStream fos = new FileOutputStream(uploadedFile);
            byte[] myarray = new byte[1024];
            int i = 0;
            while ((i = uploadedStream.read(myarray)) != -1) {
                fos.write(myarray, 0, i);
            }
            fos.flush();
            fos.close();
            uploadedStream.close();

            // update database
            try {
                getPosgresConnection().updateContentData(file, contentType, contentId);
            } catch (Exception ex) {
                // TODO delete file
                Logger.getLogger(NedFileUploadServlet.class.getSimpleName()).log(Level.SEVERE,
                        ex.getLocalizedMessage(), ex);
                resp.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
                resp.getWriter().print(NedServerResponses.ERROR_DATABASE_UPDATE);
                resp.flushBuffer();
                disconnectPostgres();
                return;
            }
        }
    }

    resp.setStatus(HttpServletResponse.SC_OK);
    resp.getWriter().print(contentType);
    resp.flushBuffer();
    disconnectPostgres();
}

From source file:org.netxilia.server.rest.WorkbookResource.java

@SuppressWarnings("unchecked")
@POST/*from w  ww  .j a v a 2 s .  c  om*/
@Path("/{workbook}/import")
@Produces({ MediaType.TEXT_HTML })
public ModelAndView<ImportSheetModel> importSheetsFromExcel(@PathParam("workbook") WorkbookId workbookId,
        @Context HttpServletRequest request) throws ImportException, IOException {

    long t1 = System.currentTimeMillis();
    List<SheetFullName> sheetNames = new ArrayList<SheetFullName>();
    StringBuilderProcessingConsole console = new StringBuilderProcessingConsole();

    if (ServletFileUpload.isMultipartContent(request)) {
        DiskFileItemFactory factory = new DiskFileItemFactory();

        ServletFileUpload upload = new ServletFileUpload(factory);
        List<FileItem> items = null;
        try {
            items = upload.parseRequest(request);
        } catch (FileUploadException e) {
            e.printStackTrace();
        }

        String format = "json";

        if (items != null) {
            // check first form fields
            for (FileItem item : items) {
                if (!item.isFormField()) {
                    continue;
                }
                String name = item.getFieldName();
                String value = item.getString();
                if ("format".equals(name)) {
                    format = value;
                }
            }
            IImportService importService = "json".equals(format) ? jsonImportService : excelImportService;
            for (FileItem item : items) {
                if (!item.isFormField() && item.getSize() > 0) {
                    sheetNames.addAll(importService.importSheets(getWorkbookProcessor(), workbookId,
                            item.getInputStream(), console));
                }
            }
        }
    }
    long t2 = System.currentTimeMillis();
    return new ModelAndView<ImportSheetModel>(
            new ImportSheetModel(sheetNames, console.getContent().toString(), (t2 - t1)),
            "/WEB-INF/jsp/workbook/importSheet.jsp");
}

From source file:org.odk.aggregate.servlet.SubmissionServlet.java

/**
 * Handler for HTTP post request that processes a form submission Currently
 * supports plain/xml and multipart//from   www.ja  v a 2s. c o  m
 * 
 * @see javax.servlet.http.HttpServlet#doGet(javax.servlet.http.HttpServletRequest,
 *      javax.servlet.http.HttpServletResponse)
 */

@Override
public void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException {
    resp.setContentType(ServletConsts.RESP_TYPE_HTML);

    PrintWriter out = resp.getWriter();
    Key submissionKey = null;
    String odkId = null;
    EntityManager em = EMFactory.get().createEntityManager();
    try {
        SubmissionParser submissionParser = null;
        if (ServletFileUpload.isMultipartContent(req)) {
            try {
                submissionParser = new SubmissionParser(new MultiPartFormData(req), em);
                odkId = submissionParser.getOdkId();
            } catch (FileUploadException e) {
                e.printStackTrace();
            }

        } else {
            // TODO: check that it is the proper types we can deal with
            // XML received
            submissionParser = new SubmissionParser(req.getInputStream(), em);
        }

        if (submissionParser == null) {
            resp.sendError(HttpServletResponse.SC_BAD_REQUEST, ErrorConsts.INPUTSTREAM_ERROR);
            return;
        }

        Form form = submissionParser.getForm();
        String appName = this.getServletContext().getInitParameter("application_name");
        Submission submission = submissionParser.getSubmission();

        List<RemoteServer> tmp = form.getExternalRepos();
        // send information to remote servers that need to be notified
        for (RemoteServer rs : tmp) {
            rs.sendSubmissionToRemoteServer(form, req.getServerName(), em, appName, submission);
        }
    } catch (ODKFormNotFoundException e) {
        odkIdNotFoundError(resp);
        return;
    } catch (ODKParseException e) {
        resp.sendError(HttpServletResponse.SC_BAD_REQUEST, ErrorConsts.PARSING_PROBLEM);
        return;
    }

    em.close();

    if (ServletConsts.DEBUG) {
        out.println("QUERYING FROM DATASTORE");

        em = EMFactory.get().createEntityManager();
        DatastoreService ds = DatastoreServiceFactory.getDatastoreService();
        try {
            if (odkId == null) {

                // TODO: make better error decision
                return;
            }
            Entity subEntity = ds.get(submissionKey);
            Form form = Form.retrieveForm(em, odkId);
            Submission test = new Submission(subEntity, form);
            test.printSubmission(out);

        } catch (EntityNotFoundException e) {
            e.printStackTrace();
        } catch (ODKFormNotFoundException e) {
            e.printStackTrace();
        } catch (ODKIncompleteSubmissionData e) {
            e.printStackTrace();
        }
        em.close();
    } else {
        resp.setStatus(HttpServletResponse.SC_CREATED);
        resp.setHeader("Location", getServerURL(req));

        // TODO: get an auto redirect going
        // resp.getWriter().print("<html><head><meta HTTP-EQUIV=\"REFRESH\" content=\"0; url=http://"
        // + getServerURL(req) + "\"></head><body></body></html>");
    }

}

From source file:org.opendatakit.aggregate.servlet.OdkTablesUploadTableFromCSVServlet.java

/**
 * Handler for HTTP Post request that takes a CSV file, uses that file to add
 * a new OdkTables table to the datastore.
 */// ww w  .  j a  va2 s.c om
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException {
    ServiceUtils.examineRequest(getServletContext(), req);
    // TODO here do I need to handle the log stuff?
    CallingContext cc = ContextFactory.getCallingContext(this, req);
    if (!ServletFileUpload.isMultipartContent(req)) {
        resp.sendError(HttpServletResponse.SC_BAD_REQUEST, ErrorConsts.NO_MULTI_PART_CONTENT);
        return;
    }

    try {
        MultiPartFormData uploadedFormItems = new MultiPartFormData(req);

        MultiPartFormItem csvFile = uploadedFormItems.getFormDataByFieldName("table_file");

        String tableName = uploadedFormItems.getSimpleFormField("table_name");

        addOpenDataKitHeaders(resp);
        resp.setStatus(HttpServletResponse.SC_CREATED);
        resp.setContentType(HtmlConsts.RESP_TYPE_PLAIN);
        resp.setCharacterEncoding(HtmlConsts.UTF8_ENCODE);

        CsvUtil csvUtil = new CsvUtil();
        byte[] bytes = csvFile.getStream().toByteArray();
        ByteArrayInputStream inputStream = new ByteArrayInputStream(bytes);
        BufferedReader br = new BufferedReader(new InputStreamReader(inputStream, CharEncoding.UTF_8));
        boolean success = csvUtil.importNewTable(br, tableName, cc);
        PrintWriter out = resp.getWriter();
        if (success) {
            out.write("The table was created successfully.");
        } else {
            // something went wrong while uploading.
            out.write("There was a problem uploading the table.");
        }
    } catch (FileUploadException e) {
        logger.error("error uploading csv: " + e.getMessage());
        e.printStackTrace();
        resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
                ErrorConsts.PERSISTENCE_LAYER_PROBLEM + "\n" + e.getMessage());
    } catch (BadColumnNameExceptionClient e) {
        logger.error("bad column name: " + e.getMessage());
        e.printStackTrace();
        resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, ErrorConsts.PERSISTENCE_LAYER_PROBLEM);
    } catch (ImportFromCSVExceptionClient e) {
        logger.error("problem importing from CSV: " + e.getMessage());
        e.printStackTrace();
        resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, ErrorConsts.PARSING_PROBLEM);
    } catch (ETagMismatchExceptionClient e) {
        logger.error("etag mismatch while importing: " + e.getMessage());
        e.printStackTrace();
        resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, ErrorConsts.PERSISTENCE_LAYER_PROBLEM);
    } catch (PermissionDeniedExceptionClient e) {
        logger.error("permission denied while uploading: " + e.getMessage());
        e.printStackTrace();
        resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, ErrorConsts.PERSISTENCE_LAYER_PROBLEM);
    } catch (EntityNotFoundExceptionClient e) {
        logger.error("entity not found while uploading: " + e.getMessage());
        e.printStackTrace();
        resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, ErrorConsts.PERSISTENCE_LAYER_PROBLEM);
    }
}

From source file:org.openhealthdata.validator.ValidatorServlet.java

/**
 * Accept a POST request with a file upload to be validated
 * Response is an XML file with an internal XSL reference
 *///from   w w  w .  j a v a  2  s.c  o m
public void doPost(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    response.setContentType("text/xml");
    PrintWriter out = response.getWriter();
    setApplicationBase(request);

    //Check that we have a file upload request
    boolean isMultipart = FileUpload.isMultipartContent(request);
    if (isMultipart) {
        // Create a new file upload handler
        DiskFileUpload upload = new DiskFileUpload();
        // Parse the request
        List items = null;
        try {
            items = upload.parseRequest(request);
        } catch (FileUploadException e) {
            logger.log(Level.SEVERE, "Exception processing upload file request", e);
            e.printStackTrace();
        }

        // Process the uploaded items
        Iterator iter = items.iterator();

        FileItem item = (FileItem) iter.next();
        StringBuffer sb = new StringBuffer();
        if (!item.isFormField()) {
            String testFileName = item.getName();
            testFileName = testFileName.replace('\\', '/');

            String[] path = testFileName.split("/");
            testFileName = path[path.length - 1];

            String[] fName = item.getName().split("\\|/");
            String fileName = "tmpValidationFile.tmp";
            if (fName.length > 0) {
                fileName = fName[fName.length - 1];
            }
            File uploadedFile = new File(fileName);
            try {
                item.write(uploadedFile);
            } catch (Exception e) {
                logger.log(Level.SEVERE, "Exception processing uploaded file item", e);
                //e.printStackTrace();
            }
            //Add XSL Reference to result XML
            // To convert to a RESTful interface, this XSL reference could be removed
            String xslRef = "<?xml-stylesheet type=\"text/xsl\" href=\"" + applicationBase
                    + "/XSLT/validationTest.xsl\"?>";
            String xmlRef = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>";
            String replaceStr = "<\\?xml version=\\\"1.0\\\" encoding=\\\"UTF-8\\\" standalone=\\\"yes\\\"\\?>";
            String valRes = validator.validateToString(uploadedFile);
            String result = valRes.replaceFirst(replaceStr, xmlRef + xslRef);
            //Add to response stream
            sb.append(result);
            //TODO Convert to save XML files
            uploadedFile.delete();
        }
        out.print(sb.toString());
    } //END if (isMultipart)    
    out.close();
}