Example usage for org.springframework.web.multipart.commons CommonsMultipartFile getFileItem

List of usage examples for org.springframework.web.multipart.commons CommonsMultipartFile getFileItem

Introduction

In this page you can find the example usage for org.springframework.web.multipart.commons CommonsMultipartFile getFileItem.

Prototype

public final FileItem getFileItem() 

Source Link

Document

Return the underlying org.apache.commons.fileupload.FileItem instance.

Usage

From source file:com.ms.commons.summer.web.multipart.CommonsMultipartEngancedResolver.java

/**
 * @param value//from www .j  av  a  2 s.co  m
 */
private void cleanSingleFileItem(CommonsMultipartFile file) {

    if (logger.isDebugEnabled()) {
        logger.debug("Cleaning up multipart file [" + file.getName() + "] with original filename ["
                + file.getOriginalFilename() + "], stored " + file.getStorageDescription());
    }
    file.getFileItem().delete();
}

From source file:eu.europa.ec.eci.oct.admin.controller.SettingsController.java

@Override
protected String _doPost(Model model, SettingsBean bean, BindingResult result, SessionStatus status,
        HttpServletRequest request, HttpServletResponse response) throws OCTException {
    if (request.getParameter("saveSettings") != null) {
        ConfigurationParameter param;/*from   w w  w. j  a  v  a  2  s .c  o  m*/

        // custom logo settings
        if (bean.isDeleteLogo()) {
            param = configurationService.getConfigurationParameter(Parameter.LOGO_PATH);

            // delete file from disk
            final String storagePath = systemManager.getSystemPreferences().getFileStoragePath();
            final File destFolder = new File(storagePath, "/custom");
            final File dest = new File(destFolder, param.getValue());
            dest.delete();

            // update db
            param.setValue(Parameter.LOGO_PATH.getDefaultValue());
            configurationService.updateParameter(param);
        } else {
            final CommonsMultipartFile file = bean.getLogoFile();
            if (file != null && !"".equals(file.getOriginalFilename())) {
                if (logger.isDebugEnabled()) {
                    logger.debug(
                            "Uploaded new logo file: " + file.getFileItem().getName() + " / " + file.getSize());
                }

                // validate uploaded logo file
                final Map<MultipartFileValidator.RejectReason, String> rejectDetailsMap = new HashMap<MultipartFileValidator.RejectReason, String>();
                rejectDetailsMap.put(RejectReason.EMPTY_CONTENT, "oct.settings.error.logo.missing");
                rejectDetailsMap.put(RejectReason.EMPTY_NAME, "oct.settings.error.logo.missing");
                rejectDetailsMap.put(RejectReason.BAD_EXTENSION, "oct.settings.error.logo.badExtension");
                rejectDetailsMap.put(RejectReason.MAX_SIZE_EXCEEDED, "oct.settings.error.logo.toobig");

                final Validator validator = new MultipartFileValidator(getCurrentMessageBundle(request),
                        "oct.settings.error.logo.upload", rejectDetailsMap, uploadExtensionWhitelist, 150000);
                validator.validate(file, result);
                if (result.hasErrors()) {
                    return doGet(model, request, response);
                }

                // validation passed, save file to needed location and
                // update the db
                final String storagePath = systemManager.getSystemPreferences().getFileStoragePath();
                final File destFolder = new File(storagePath, "/custom");
                if (!destFolder.exists()) {
                    boolean dirCreated = destFolder.mkdirs();
                    if (logger.isDebugEnabled()) {
                        logger.debug(
                                "Storage directory \"" + destFolder.getPath() + "\" created? => " + dirCreated);
                    }
                }

                final String extension = file.getOriginalFilename()
                        .substring(file.getOriginalFilename().lastIndexOf('.'));
                final String fileName = new StringBuilder().append("customlogo")
                        .append(System.currentTimeMillis()).append(extension).toString();

                final File dest = new File(destFolder, fileName);
                try {
                    file.transferTo(dest);
                    if (logger.isDebugEnabled()) {
                        logger.debug("Uploaded logo file successfully transfered to the local file "
                                + dest.getAbsolutePath());
                    }
                } catch (IllegalStateException e) {
                    logger.error("illegal state error while uploading logo", e);
                    result.reject("oct.settings.error.logo.upload", "Error uploading logo");
                    return doGet(model, request, response);
                } catch (IOException e) {
                    logger.error("input/output error while uploading logo", e);
                    result.reject("oct.settings.error.logo.upload", e.getMessage());
                    return doGet(model, request, response);
                }

                param = new ConfigurationParameter();
                param.setParam(Parameter.LOGO_PATH.getKey());
                param.setValue(fileName);
                configurationService.updateParameter(param);
            }
        }

        // callback url
        final String callbackUrl = bean.getCallbackUrl();
        if (callbackUrl != null && !"".equals(callbackUrl)) {
            // validate url
            UrlValidator validator = UrlValidator.getInstance();
            if (!validator.isValid(callbackUrl)) {
                result.rejectValue("callbackUrl", "oct.settings.error.callback.invalidurl",
                        "An invalid URL has been specified.");
                return doGet(model, request, response);
            }
        }
        param = new ConfigurationParameter();
        param.setParam(Parameter.CALLBACK_URL.getKey());
        param.setValue(callbackUrl);
        configurationService.updateParameter(param);

        // optional validation
        param = new ConfigurationParameter();
        param.setParam(Parameter.OPTIONAL_VALIDATION.getKey());
        param.setValue(new Boolean(bean.getOptionalValidation()).toString());
        configurationService.updateParameter(param);

        // distribution map
        param = new ConfigurationParameter();
        param.setParam(Parameter.SHOW_DISTRIBUTION_MAP.getKey());
        param.setValue(new Boolean(bean.getDisplayMap()).toString());
        configurationService.updateParameter(param);
    }

    return "redirect:settings.do";
}

From source file:com.carfinance.module.common.service.CommonService.java

public Map<String, Object> saveFile(CommonsMultipartFile upload_file, String save_path) {
    try {/*from   w w  w  .ja v a2  s  .c om*/
        File f = new File(save_path);
        if (!f.exists()) {
            logger.info("" + save_path);
            f.mkdirs();
        }
        String name = upload_file.getFileItem().getName();
        String extName = "";
        String annexName = "";
        if (name.lastIndexOf(".") >= 0) {
            name = name.substring(name.lastIndexOf("\\") + 1);
            extName = name.substring(name.lastIndexOf("."));
            annexName = name.substring(0, name.lastIndexOf("."));
        }
        if (!"".equals(extName)) {
            name = UUID.randomUUID().toString();
            File file = new File(save_path + name + extName);
            upload_file.getFileItem().write(file);

            String file_name = name + extName;
            Map<String, Object> map = new HashMap<String, Object>();
            map.put("annexName", annexName);
            map.put("file_name", file_name);
            return map;
        }
    } catch (Exception e) {
        logger.error(e.getMessage(), e);
    }
    return null;
}

From source file:com.suntek.gztpb.controller.DriverLicenseController.java

@RequestMapping(value = "upload.htm", method = RequestMethod.POST) //
public String handleFormUpload(HttpServletRequest request, HttpServletResponse response) throws IOException {
    MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
    String inputName = request.getParameter("name");
    CommonsMultipartFile mFile = (CommonsMultipartFile) multipartRequest.getFile(inputName);

    if (!mFile.isEmpty()) {
        String path = this.servletContext.getRealPath("/picUpload/");
        SimpleDateFormat format = new SimpleDateFormat("yyyyMMddHHmmss");
        String fileName = format.format(new Date()) + "_" + mFile.getOriginalFilename();
        File fold = new File(path);
        if (!fold.exists()) {
            fold.mkdir();/*from w  w w .  j  a  v a2s.c o m*/
        }
        path = path + "\\" + fileName; // ?

        File file = new File(path); // 

        response.setContentType("text/html");
        response.setCharacterEncoding("utf-8");
        PrintWriter out = response.getWriter();

        try {
            mFile.getFileItem().write(file); // 
            out.write("<script>parent.callback(1,'" + fileName + "','" + inputName + "')</script>");
        } catch (Exception e) {
            logger.error(e.getMessage());
            out.write("<script>parent.callback(0)</script>");
        }
    }
    return null;
}

From source file:org.bibsonomy.webapp.controller.actions.JabRefImportController.java

/**
 * Writes the file of the specified layout part to disk and into the 
 * database./*from   ww w .  j a  va 2s  .c om*/
 * 
 * @param loginUser
 * @param fileItem
 * @param layoutPart
 */
private void writeLayoutPart(final User loginUser, final CommonsMultipartFile fileItem,
        final LayoutPart layoutPart) {
    if (fileItem != null && fileItem.getSize() > 0) {
        log.debug("writing layout part " + layoutPart + " with file " + fileItem.getOriginalFilename());
        try {
            final String hashedName = JabrefLayoutUtils.userLayoutHash(loginUser.getName(), layoutPart);

            final FileUploadInterface uploadFileHandler = this.uploadFactory.getFileUploadHandler(
                    Collections.singletonList(fileItem.getFileItem()), FileUploadInterface.fileLayoutExt);
            /*
             * write file to disk
             */
            final Document uploadedFile = uploadFileHandler.writeUploadedFile(hashedName, loginUser);
            /*
             * store row in database
             */
            this.logic.createDocument(uploadedFile, null);
        } catch (Exception ex) {
            log.error("Could not add custom " + layoutPart + " layout." + ex.getMessage());
            throw new RuntimeException("Could not add custom " + layoutPart + " layout: " + ex.getMessage());
        }
    }
}

From source file:org.bibsonomy.webapp.controller.actions.PostPublicationController.java

/**
 * Handles an uploaded file and returns its contents - if necessary 
 * after converting EndNote to BibTeX;//w  w w .  j  ava2  s.  c  o m
 * 
 * @param command
 * @return
 */
private String handleFileUpload(final PostPublicationCommand command) {
    /*
     * get temp file
     */
    File file = null;
    try {

        final CommonsMultipartFile uploadedFile = command.getFile();
        final FileUploadInterface uploadFileHandler = this.uploadFactory.getFileUploadHandler(
                Collections.singletonList(uploadedFile.getFileItem()), FileUploadInterface.bibtexEndnoteExt);
        /*
         * FIXME: the upload file handler throws an exception, 
         * if the file type does not match - this exception also comes, when
         * no file is given at all. We should check for empty file names and
         * give a specific error message then.
         */
        final Document uploadedDocument = uploadFileHandler.writeUploadedFile();
        file = uploadedDocument.getFile();

        final String fileName = uploadedDocument.getFileName();

        final BufferedReader reader = new BufferedReader(
                new InputStreamReader(new FileInputStream(file), command.getEncoding()));

        String fileContent = null;
        if (StringUtils.matchExtension(fileName, FileUploadInterface.bibtexEndnoteExt[1])) {
            /*
             * In case the uploaded file is in EndNote format, we convert it to BibTeX.            
             */
            log.debug("the file is in EndNote format");
            fileContent = e2bConverter.endnoteToBibtexString(reader);
        } else {
            /*
             * or just use it as it is ...
             */
            log.debug("the file is in BibTeX format");
            fileContent = StringUtils.getStringFromReader(reader);
        }
        if (present(fileContent)) {
            return fileContent;
        }
        errors.reject("error.upload.failed.emptyFile", "The specified file is empty.");
        return null;

    } catch (final ConversionException e) {
        errors.reject("error.upload.failed.conversion",
                "An error occurred during converting your EndNote file to BibTeX.");
    } catch (final UnsupportedFileTypeException e) {
        /*
         * FIXME: the key is missing! We need to get the supported file types from the exception
         */
        errors.reject("error.upload.failed.filetype", FileUploadInterface.bibtexEndnoteExt, e.getMessage());
    } catch (final Exception ex1) {
        errors.reject("error.upload.failed.fileAccess", "An error occurred while accessing your file.");
    } finally {
        /*
         * clear temporary file
         * FIXME: is this method always called?
         */
        log.debug("deleting uploaded temp file");
        if (file != null) {
            file.delete();
        }
    }
    return null;
}

From source file:org.springframework.web.multipart.commons.CommonsFileUploadSupport.java

/**
 * Cleanup the Spring MultipartFiles created during multipart parsing,
 * potentially holding temporary data on disk.
 * <p>Deletes the underlying Commons FileItem instances.
 * @param multipartFiles Collection of MultipartFile instances
 * @see org.apache.commons.fileupload.FileItem#delete()
 *//*from  w ww.ja v a  2  s  .  co  m*/
protected void cleanupFileItems(MultiValueMap<String, MultipartFile> multipartFiles) {
    for (List<MultipartFile> files : multipartFiles.values()) {
        for (MultipartFile file : files) {
            if (file instanceof CommonsMultipartFile) {
                CommonsMultipartFile cmf = (CommonsMultipartFile) file;
                cmf.getFileItem().delete();
                if (logger.isDebugEnabled()) {
                    logger.debug("Cleaning up multipart file [" + cmf.getName() + "] with original filename ["
                            + cmf.getOriginalFilename() + "], stored " + cmf.getStorageDescription());
                }
            }
        }
    }
}

From source file:org.springframework.web.multipart.commons.CommonsMultipartResolverTests.java

private void doTestFiles(MultipartHttpServletRequest request) throws IOException {
    Set<String> fileNames = new HashSet<>();
    Iterator<String> fileIter = request.getFileNames();
    while (fileIter.hasNext()) {
        fileNames.add(fileIter.next());/*from  ww w.ja  v a 2  s .  com*/
    }
    assertEquals(3, fileNames.size());
    assertTrue(fileNames.contains("field1"));
    assertTrue(fileNames.contains("field2"));
    assertTrue(fileNames.contains("field2x"));
    CommonsMultipartFile file1 = (CommonsMultipartFile) request.getFile("field1");
    CommonsMultipartFile file2 = (CommonsMultipartFile) request.getFile("field2");
    CommonsMultipartFile file2x = (CommonsMultipartFile) request.getFile("field2x");

    Map<String, MultipartFile> fileMap = request.getFileMap();
    assertEquals(3, fileMap.size());
    assertTrue(fileMap.containsKey("field1"));
    assertTrue(fileMap.containsKey("field2"));
    assertTrue(fileMap.containsKey("field2x"));
    assertEquals(file1, fileMap.get("field1"));
    assertEquals(file2, fileMap.get("field2"));
    assertEquals(file2x, fileMap.get("field2x"));

    MultiValueMap<String, MultipartFile> multiFileMap = request.getMultiFileMap();
    assertEquals(3, multiFileMap.size());
    assertTrue(multiFileMap.containsKey("field1"));
    assertTrue(multiFileMap.containsKey("field2"));
    assertTrue(multiFileMap.containsKey("field2x"));
    List<MultipartFile> field1Files = multiFileMap.get("field1");
    assertEquals(2, field1Files.size());
    assertTrue(field1Files.contains(file1));
    assertEquals(file1, multiFileMap.getFirst("field1"));
    assertEquals(file2, multiFileMap.getFirst("field2"));
    assertEquals(file2x, multiFileMap.getFirst("field2x"));

    assertEquals("type1", file1.getContentType());
    assertEquals("type2", file2.getContentType());
    assertEquals("type2", file2x.getContentType());
    assertEquals("field1.txt", file1.getOriginalFilename());
    assertEquals("field2.txt", file2.getOriginalFilename());
    assertEquals("field2x.txt", file2x.getOriginalFilename());
    assertEquals("text1", new String(file1.getBytes()));
    assertEquals("text2", new String(file2.getBytes()));
    assertEquals(5, file1.getSize());
    assertEquals(5, file2.getSize());
    assertTrue(file1.getInputStream() instanceof ByteArrayInputStream);
    assertTrue(file2.getInputStream() instanceof ByteArrayInputStream);
    File transfer1 = new File("C:/transfer1");
    file1.transferTo(transfer1);
    File transfer2 = new File("C:/transfer2");
    file2.transferTo(transfer2);
    assertEquals(transfer1, ((MockFileItem) file1.getFileItem()).writtenFile);
    assertEquals(transfer2, ((MockFileItem) file2.getFileItem()).writtenFile);

}

From source file:org.springframework.web.multipart.commons.CommonsMultipartResolverTests.java

private void doTestBinding(MockCommonsMultipartResolver resolver, MockHttpServletRequest originalRequest,
        MultipartHttpServletRequest request) throws UnsupportedEncodingException {

    MultipartTestBean1 mtb1 = new MultipartTestBean1();
    assertArrayEquals(null, mtb1.getField1());
    assertEquals(null, mtb1.getField2());
    ServletRequestDataBinder binder = new ServletRequestDataBinder(mtb1, "mybean");
    binder.registerCustomEditor(byte[].class, new ByteArrayMultipartFileEditor());
    binder.bind(request);//from www. j av a  2s .co m
    List<MultipartFile> file1List = request.getFiles("field1");
    CommonsMultipartFile file1a = (CommonsMultipartFile) file1List.get(0);
    CommonsMultipartFile file1b = (CommonsMultipartFile) file1List.get(1);
    CommonsMultipartFile file2 = (CommonsMultipartFile) request.getFile("field2");
    assertEquals(file1a, mtb1.getField1()[0]);
    assertEquals(file1b, mtb1.getField1()[1]);
    assertEquals(new String(file2.getBytes()), new String(mtb1.getField2()));

    MultipartTestBean2 mtb2 = new MultipartTestBean2();
    assertArrayEquals(null, mtb2.getField1());
    assertEquals(null, mtb2.getField2());
    binder = new ServletRequestDataBinder(mtb2, "mybean");
    binder.registerCustomEditor(String.class, "field1", new StringMultipartFileEditor());
    binder.registerCustomEditor(String.class, "field2", new StringMultipartFileEditor("UTF-16"));
    binder.bind(request);
    assertEquals(new String(file1a.getBytes()), mtb2.getField1()[0]);
    assertEquals(new String(file1b.getBytes()), mtb2.getField1()[1]);
    assertEquals(new String(file2.getBytes(), "UTF-16"), mtb2.getField2());

    resolver.cleanupMultipart(request);
    assertTrue(((MockFileItem) file1a.getFileItem()).deleted);
    assertTrue(((MockFileItem) file1b.getFileItem()).deleted);
    assertTrue(((MockFileItem) file2.getFileItem()).deleted);

    resolver.setEmpty(true);
    request = resolver.resolveMultipart(originalRequest);
    binder.setBindEmptyMultipartFiles(false);
    String firstBound = mtb2.getField2();
    binder.bind(request);
    assertFalse(mtb2.getField2().isEmpty());
    assertEquals(firstBound, mtb2.getField2());

    request = resolver.resolveMultipart(originalRequest);
    binder.setBindEmptyMultipartFiles(true);
    binder.bind(request);
    assertTrue(mtb2.getField2().isEmpty());
}

From source file:org.springframework.web.multipart.commons.CommonsMultipartResolverTests.java

@Test
public void withServletContextAndFilter() throws Exception {
    StaticWebApplicationContext wac = new StaticWebApplicationContext();
    wac.setServletContext(new MockServletContext());
    wac.registerSingleton("filterMultipartResolver", MockCommonsMultipartResolver.class,
            new MutablePropertyValues());
    wac.getServletContext().setAttribute(WebUtils.TEMP_DIR_CONTEXT_ATTRIBUTE, new File("mytemp"));
    wac.refresh();// w w w.  ja  v  a 2s  .c  o  m
    wac.getServletContext().setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, wac);
    CommonsMultipartResolver resolver = new CommonsMultipartResolver(wac.getServletContext());
    assertTrue(resolver.getFileItemFactory().getRepository().getAbsolutePath().endsWith("mytemp"));

    MockFilterConfig filterConfig = new MockFilterConfig(wac.getServletContext(), "filter");
    filterConfig.addInitParameter("class", "notWritable");
    filterConfig.addInitParameter("unknownParam", "someValue");
    final MultipartFilter filter = new MultipartFilter();
    filter.init(filterConfig);

    final List<MultipartFile> files = new ArrayList<>();
    final FilterChain filterChain = new FilterChain() {
        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse) {
            MultipartHttpServletRequest request = (MultipartHttpServletRequest) servletRequest;
            files.addAll(request.getFileMap().values());
        }
    };

    FilterChain filterChain2 = new PassThroughFilterChain(filter, filterChain);

    MockHttpServletRequest originalRequest = new MockHttpServletRequest();
    MockHttpServletResponse response = new MockHttpServletResponse();
    originalRequest.setMethod("POST");
    originalRequest.setContentType("multipart/form-data");
    originalRequest.addHeader("Content-type", "multipart/form-data");
    filter.doFilter(originalRequest, response, filterChain2);

    CommonsMultipartFile file1 = (CommonsMultipartFile) files.get(0);
    CommonsMultipartFile file2 = (CommonsMultipartFile) files.get(1);
    assertTrue(((MockFileItem) file1.getFileItem()).deleted);
    assertTrue(((MockFileItem) file2.getFileItem()).deleted);
}