Example usage for org.apache.commons.fileupload FileItem getInputStream

List of usage examples for org.apache.commons.fileupload FileItem getInputStream

  1. HOME
  2. Java
  3. org.apache.commons
  4. org.apache.commons.fileupload.*
  5. FileItem
  6. getInputStream

Introduction

In this page you can find the example usage for org.apache.commons.fileupload FileItem getInputStream.

Prototype

InputStream getInputStream() throws IOException;

Source Link

Document

Returns an java.io.InputStream InputStream that can be used to retrieve the contents of the file.

Usage

From source file:hu.sztaki.lpds.pgportal.portlets.credential.MyProxyPortlet.java

/**
 * Checks if the file input field was selected, if the file exists and
 * if the file is not null. Proper error messages are set, showed on the GUI.
 * @param req ActionRequest/*  ww  w  .ja v  a2 s.co  m*/
 * @param type String contains the selected type (p12, pem or saml)
 * @param f FileItem containing the uploaded file
 * @return Boolean
 */
private Boolean checkFile(ActionRequest req, String type, FileItem f) {
    ActionRequest request = req;

    try {
        if (f == null || "".equals(f.getName())) {
            request.setAttribute("msg", type + " file must be selected!");
            return false;
        }
        if (f.getInputStream() == null) {
            request.setAttribute("msg", "Selected " + type + " file does not exists!");
            return false;
        }
        if (f.getInputStream().available() == 0) {
            request.setAttribute("msg", "Selected" + type + " file does not exists!");
            return false;
        }
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}

From source file:com.ikon.servlet.admin.OmrServlet.java

@SuppressWarnings("unchecked")
public void doPost(HttpServletRequest request, HttpServletResponse response)
        throws IOException, ServletException {
    log.debug("doPost({}, {})", request, response);
    request.setCharacterEncoding("UTF-8");
    String action = "";
    String userId = request.getRemoteUser();
    updateSessionManager(request);// ww w .  jav a2  s  .com

    try {
        if (ServletFileUpload.isMultipartContent(request)) {
            String fileName = null;
            InputStream is = null;
            FileItemFactory factory = new DiskFileItemFactory();
            ServletFileUpload upload = new ServletFileUpload(factory);
            List<FileItem> items = upload.parseRequest(request);
            Set<String> properties = new HashSet<String>();
            Omr om = new Omr();

            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("om_id")) {
                        om.setId(Integer.parseInt(item.getString("UTF-8")));
                    } else if (item.getFieldName().equals("om_name")) {
                        om.setName(item.getString("UTF-8"));
                    } else if (item.getFieldName().equals("om_properties")) {
                        properties.add(item.getString("UTF-8"));
                    } else if (item.getFieldName().equals("om_active")) {
                        om.setActive(true);
                    }
                } else {
                    is = item.getInputStream();
                    fileName = item.getName();
                }
            }

            om.setProperties(properties);

            if (action.equals("create") || action.equals("edit")) {
                // Store locally template file to be used later
                if (is != null && is.available() > 0) { // Case update only name
                    byte[] data = IOUtils.toByteArray(is);
                    File tmp = FileUtils.createTempFile();
                    FileOutputStream fos = new FileOutputStream(tmp);
                    IOUtils.write(data, fos);
                    IOUtils.closeQuietly(fos);

                    // Store template file
                    om.setTemplateFileName(FilenameUtils.getName(fileName));
                    om.setTemplateFileMime(MimeTypeConfig.mimeTypes.getContentType(fileName));
                    om.setTemplateFilContent(data);
                    IOUtils.closeQuietly(is);

                    // Create training files
                    Map<String, File> trainingMap = OMRHelper.trainingTemplate(tmp);
                    File ascFile = trainingMap.get(OMRHelper.ASC_FILE);
                    File configFile = trainingMap.get(OMRHelper.CONFIG_FILE);

                    // Store asc file
                    om.setAscFileName(om.getTemplateFileName() + ".asc");
                    om.setAscFileMime(MimeTypeConfig.MIME_TEXT);
                    is = new FileInputStream(ascFile);
                    om.setAscFileContent(IOUtils.toByteArray(is));
                    IOUtils.closeQuietly(is);

                    // Store config file
                    om.setConfigFileName(om.getTemplateFileName() + ".config");
                    om.setConfigFileMime(MimeTypeConfig.MIME_TEXT);
                    is = new FileInputStream(configFile);
                    om.setConfigFileContent(IOUtils.toByteArray(is));
                    IOUtils.closeQuietly(is);

                    // Delete temporal files
                    FileUtils.deleteQuietly(tmp);
                    FileUtils.deleteQuietly(ascFile);
                    FileUtils.deleteQuietly(configFile);
                }

                if (action.equals("create")) {
                    long id = OmrDAO.getInstance().create(om);

                    // Activity log
                    UserActivity.log(userId, "ADMIN_OMR_CREATE", Long.toString(id), null, om.toString());
                } else if (action.equals("edit")) {
                    OmrDAO.getInstance().updateTemplate(om);
                    om = OmrDAO.getInstance().findByPk(om.getId());

                    // Activity log
                    UserActivity.log(userId, "ADMIN_OMR_EDIT", Long.toString(om.getId()), null, om.toString());
                }

                list(userId, request, response);
            } else if (action.equals("delete")) {
                OmrDAO.getInstance().delete(om.getId());

                // Activity log
                UserActivity.log(userId, "ADMIN_OMR_DELETE", Long.toString(om.getId()), null, null);
                list(userId, request, response);
            } else if (action.equals("editAsc")) {
                Omr omr = OmrDAO.getInstance().findByPk(om.getId());
                omr.setAscFileContent(IOUtils.toByteArray(is));
                omr.setAscFileMime(MimeTypeConfig.MIME_TEXT);
                omr.setAscFileName(omr.getTemplateFileName() + ".asc");
                OmrDAO.getInstance().update(omr);
                omr = OmrDAO.getInstance().findByPk(om.getId());
                IOUtils.closeQuietly(is);

                // Activity log
                UserActivity.log(userId, "ADMIN_OMR_EDIT_ASC", Long.toString(om.getId()), null, null);
                list(userId, request, response);
            } else if (action.equals("editFields")) {
                Omr omr = OmrDAO.getInstance().findByPk(om.getId());
                omr.setFieldsFileContent(IOUtils.toByteArray(is));
                omr.setFieldsFileMime(MimeTypeConfig.MIME_TEXT);
                omr.setFieldsFileName(omr.getTemplateFileName() + ".fields");
                OmrDAO.getInstance().update(omr);
                omr = OmrDAO.getInstance().findByPk(om.getId());
                IOUtils.closeQuietly(is);

                // Activity log
                UserActivity.log(userId, "ADMIN_OMR_EDIT_FIELDS", Long.toString(om.getId()), null, null);
                list(userId, request, response);
            } else if (action.equals("check")) {
                File form = FileUtils.createTempFile();
                OutputStream formFile = new FileOutputStream(form);
                formFile.write(IOUtils.toByteArray(is));
                IOUtils.closeQuietly(formFile);
                formFile.close();
                Map<String, String> results = OMRHelper.process(form, om.getId());
                FileUtils.deleteQuietly(form);
                IOUtils.closeQuietly(is);
                UserActivity.log(userId, "ADMIN_OMR_CHECK_TEMPLATE", Long.toString(om.getId()), null, null);
                results(userId, request, response, action, results, om.getId());
            }
        }
    } 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 (OMRException e) {
        log.error(e.getMessage(), e);
        sendErrorRedirect(request, response, e);
    } catch (InvalidFileStructureException e) {
        log.error(e.getMessage(), e);
        sendErrorRedirect(request, response, e);
    } catch (InvalidImageIndexException e) {
        log.error(e.getMessage(), e);
        sendErrorRedirect(request, response, e);
    } catch (UnsupportedTypeException e) {
        log.error(e.getMessage(), e);
        sendErrorRedirect(request, response, e);
    } catch (MissingParameterException e) {
        log.error(e.getMessage(), e);
        sendErrorRedirect(request, response, e);
    } catch (WrongParameterException e) {
        log.error(e.getMessage(), e);
        sendErrorRedirect(request, response, e);
    }
}

From source file:com.ikon.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;/*from   w ww .  j ava 2s. co  m*/
    String filter = null;
    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);
            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();
                    data = IOUtils.toByteArray(is);
                    is.close();
                }
            }

            if (action.equals("create")) {
                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.ikon.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.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.ikon.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.ikon.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:edu.ucsb.eucalyptus.transport.query.WalrusQueryDispatcher.java

public String getOperation(HttpRequest httpRequest, MessageContext messageContext)
        throws EucalyptusCloudException {
    //Figure out if it is an operation on the service, a bucket or an object
    Map operationParams = new HashMap();
    String[] target = null;/*  w  w  w. j  a  v  a2  s .  com*/
    String path = httpRequest.getOperationPath();
    boolean walrusInternalOperation = false;
    if (path.length() > 0) {
        target = getTarget(path);
    }

    String verb = httpRequest.getHttpMethod();
    Map<String, String> headers = httpRequest.getHeaders();
    CaseInsensitiveMap caseInsensitiveHeaders = new CaseInsensitiveMap(headers);
    String operationKey = "";
    Map<String, String> params = httpRequest.getParameters();
    String operationName = null;
    long contentLength = 0;
    String contentLengthString = (String) messageContext.getProperty(HTTP.CONTENT_LEN);
    if (contentLengthString != null) {
        contentLength = Long.parseLong(contentLengthString);
    }
    if (caseInsensitiveHeaders.containsKey(StorageProperties.EUCALYPTUS_OPERATION)) {
        String value = caseInsensitiveHeaders.get(StorageProperties.EUCALYPTUS_OPERATION);
        for (WalrusProperties.WalrusInternalOperations operation : WalrusProperties.WalrusInternalOperations
                .values()) {
            if (value.toLowerCase().equals(operation.toString().toLowerCase())) {
                operationName = operation.toString();
                walrusInternalOperation = true;
                break;
            }
        }

        if (!walrusInternalOperation) {
            for (WalrusProperties.StorageOperations operation : WalrusProperties.StorageOperations.values()) {
                if (value.toLowerCase().equals(operation.toString().toLowerCase())) {
                    operationName = operation.toString();
                    walrusInternalOperation = true;
                    break;
                }
            }
        }

    }

    if (target == null) {
        //target = service
        operationKey = SERVICE + verb;
    } else if (target.length < 2) {
        //target = bucket
        if (!target[0].equals("")) {
            operationKey = BUCKET + verb;
            operationParams.put("Bucket", target[0]);

            if (verb.equals(HTTPVerb.POST.toString())) {
                InputStream in = (InputStream) messageContext.getProperty("TRANSPORT_IN");
                messageContext.setProperty(WalrusProperties.STREAMING_HTTP_PUT, Boolean.TRUE);
                String contentType = caseInsensitiveHeaders.get(HTTP.CONTENT_TYPE);
                int postContentLength = Integer.parseInt(caseInsensitiveHeaders.get(HTTP.CONTENT_LEN));
                POSTRequestContext postRequestContext = new POSTRequestContext(in, contentType,
                        postContentLength);
                FileUpload fileUpload = new FileUpload(new WalrusFileItemFactory());
                InputStream formDataIn = null;
                String objectKey = null;
                String file = "";
                String key;
                Map<String, String> formFields = new HashMap<String, String>();
                try {
                    List<FileItem> parts = fileUpload.parseRequest(postRequestContext);
                    for (FileItem part : parts) {
                        if (part.isFormField()) {
                            String fieldName = part.getFieldName().toString().toLowerCase();
                            InputStream formFieldIn = part.getInputStream();
                            int bytesRead;
                            String fieldValue = "";
                            byte[] bytes = new byte[512];
                            while ((bytesRead = formFieldIn.read(bytes)) > 0) {
                                fieldValue += new String(bytes, 0, bytesRead);
                            }
                            formFields.put(fieldName, fieldValue);
                        } else {
                            formDataIn = part.getInputStream();
                            if (part.getName() != null)
                                file = part.getName();
                        }
                    }
                } catch (Exception ex) {
                    LOG.warn(ex, ex);
                    throw new EucalyptusCloudException("could not process form request");
                }

                String authenticationHeader = "";
                formFields.put(WalrusProperties.FormField.bucket.toString(), target[0]);
                if (formFields.containsKey(WalrusProperties.FormField.key.toString())) {
                    objectKey = formFields.get(WalrusProperties.FormField.key.toString());
                    objectKey = objectKey.replaceAll("\\$\\{filename\\}", file);
                }
                if (formFields.containsKey(WalrusProperties.FormField.acl.toString())) {
                    String acl = formFields.get(WalrusProperties.FormField.acl.toString());
                    headers.put(WalrusProperties.AMZ_ACL, acl);
                }
                if (formFields.containsKey(WalrusProperties.FormField.success_action_redirect.toString())) {
                    String successActionRedirect = formFields
                            .get(WalrusProperties.FormField.success_action_redirect.toString());
                    operationParams.put("SuccessActionRedirect", successActionRedirect);
                }
                if (formFields.containsKey(WalrusProperties.FormField.success_action_status.toString())) {
                    Integer successActionStatus = Integer.parseInt(
                            formFields.get(WalrusProperties.FormField.success_action_status.toString()));
                    if (successActionStatus == 200 || successActionStatus == 201)
                        operationParams.put("SuccessActionStatus", successActionStatus);
                    else
                        operationParams.put("SuccessActionStatus", 204);
                } else {
                    operationParams.put("SuccessActionStatus", 204);
                }
                if (formFields.containsKey(WalrusProperties.FormField.policy.toString())) {
                    String policy = new String(
                            Base64.decode(formFields.remove(WalrusProperties.FormField.policy.toString())));
                    String policyData;
                    try {
                        policyData = new String(Base64.encode(policy.getBytes()));
                    } catch (Exception ex) {
                        LOG.warn(ex, ex);
                        throw new EucalyptusCloudException("error reading policy data.");
                    }
                    //parse policy
                    try {
                        JSONObject policyObject = new JSONObject(policy);
                        String expiration = (String) policyObject
                                .get(WalrusProperties.PolicyHeaders.expiration.toString());
                        if (expiration != null) {
                            Date expirationDate = DateUtils.parseIso8601DateTimeOrDate(expiration);
                            if ((new Date()).getTime() > expirationDate.getTime()) {
                                LOG.warn("Policy has expired.");
                                //TODO: currently this will be reported as an invalid operation
                                //Fix this to report a security exception
                                throw new EucalyptusCloudException("Policy has expired.");
                            }
                        }
                        List<String> policyItemNames = new ArrayList<String>();

                        JSONArray conditions = (JSONArray) policyObject
                                .get(WalrusProperties.PolicyHeaders.conditions.toString());
                        for (int i = 0; i < conditions.length(); ++i) {
                            Object policyItem = conditions.get(i);
                            if (policyItem instanceof JSONObject) {
                                JSONObject jsonObject = (JSONObject) policyItem;
                                if (!exactMatch(jsonObject, formFields, policyItemNames)) {
                                    LOG.warn("Policy verification failed. ");
                                    throw new EucalyptusCloudException("Policy verification failed.");
                                }
                            } else if (policyItem instanceof JSONArray) {
                                JSONArray jsonArray = (JSONArray) policyItem;
                                if (!partialMatch(jsonArray, formFields, policyItemNames)) {
                                    LOG.warn("Policy verification failed. ");
                                    throw new EucalyptusCloudException("Policy verification failed.");
                                }
                            }
                        }

                        Set<String> formFieldsKeys = formFields.keySet();
                        for (String formKey : formFieldsKeys) {
                            if (formKey.startsWith(WalrusProperties.IGNORE_PREFIX))
                                continue;
                            boolean fieldOkay = false;
                            for (WalrusProperties.IgnoredFields field : WalrusProperties.IgnoredFields
                                    .values()) {
                                if (formKey.equals(field.toString().toLowerCase())) {
                                    fieldOkay = true;
                                    break;
                                }
                            }
                            if (fieldOkay)
                                continue;
                            if (policyItemNames.contains(formKey))
                                continue;
                            LOG.warn("All fields except those marked with x-ignore- should be in policy.");
                            throw new EucalyptusCloudException(
                                    "All fields except those marked with x-ignore- should be in policy.");
                        }
                    } catch (Exception ex) {
                        //rethrow
                        if (ex instanceof EucalyptusCloudException)
                            throw (EucalyptusCloudException) ex;
                        LOG.warn(ex);
                    }
                    //all form uploads without a policy are anonymous
                    if (formFields
                            .containsKey(WalrusProperties.FormField.AWSAccessKeyId.toString().toLowerCase())) {
                        String accessKeyId = formFields
                                .remove(WalrusProperties.FormField.AWSAccessKeyId.toString().toLowerCase());
                        authenticationHeader += "AWS" + " " + accessKeyId + ":";
                    }
                    if (formFields.containsKey(WalrusProperties.FormField.signature.toString())) {
                        String signature = formFields.remove(WalrusProperties.FormField.signature.toString());
                        authenticationHeader += signature;
                        headers.put(HMACQuerySecurityHandler.SecurityParameter.Authorization.toString(),
                                authenticationHeader);
                    }
                    headers.put(WalrusProperties.FormField.FormUploadPolicyData.toString(), policyData);
                }
                operationParams.put("Key", objectKey);
                key = target[0] + "." + objectKey;
                String randomKey = key + "." + Hashes.getRandom(10);
                LinkedBlockingQueue<WalrusDataMessage> putQueue = getWriteMessenger()
                        .interruptAllAndGetQueue(key, randomKey);

                Writer writer = new Writer(formDataIn, postContentLength, putQueue);
                writer.start();

                operationParams.put("ContentLength", (new Long(postContentLength).toString()));
                operationParams.put(WalrusProperties.Headers.RandomKey.toString(), randomKey);
            }

        } else {
            operationKey = SERVICE + verb;
        }
    } else {
        //target = object
        operationKey = OBJECT + verb;
        String objectKey = "";
        String splitOn = "";
        for (int i = 1; i < target.length; ++i) {
            objectKey += splitOn + target[i];
            splitOn = "/";
        }
        operationParams.put("Bucket", target[0]);
        operationParams.put("Key", objectKey);

        if (!params.containsKey(OperationParameter.acl.toString())) {
            if (verb.equals(HTTPVerb.PUT.toString())) {
                if (caseInsensitiveHeaders.containsKey(WalrusProperties.COPY_SOURCE.toString())) {
                    String copySource = caseInsensitiveHeaders.get(WalrusProperties.COPY_SOURCE.toString());
                    String[] sourceTarget = getTarget(copySource);
                    String sourceObjectKey = "";
                    String sourceSplitOn = "";
                    if (sourceTarget.length > 1) {
                        for (int i = 1; i < sourceTarget.length; ++i) {
                            sourceObjectKey += sourceSplitOn + sourceTarget[i];
                            sourceSplitOn = "/";
                        }
                        operationParams.put("SourceBucket", sourceTarget[0]);
                        operationParams.put("SourceObject", sourceObjectKey);
                        operationParams.put("DestinationBucket", operationParams.remove("Bucket"));
                        operationParams.put("DestinationObject", operationParams.remove("Key"));

                        String metaDataDirective = caseInsensitiveHeaders
                                .get(WalrusProperties.METADATA_DIRECTIVE.toString());
                        if (metaDataDirective != null) {
                            operationParams.put("MetadataDirective", metaDataDirective);
                        }
                        AccessControlListType accessControlList;
                        if (contentLength > 0) {
                            InputStream in = (InputStream) messageContext.getProperty("TRANSPORT_IN");
                            accessControlList = getAccessControlList(in);
                        } else {
                            accessControlList = new AccessControlListType();
                        }
                        operationParams.put("AccessControlList", accessControlList);
                        operationKey += WalrusProperties.COPY_SOURCE.toString();
                        Iterator<String> iterator = caseInsensitiveHeaders.keySet().iterator();
                        while (iterator.hasNext()) {
                            String key = iterator.next();
                            for (WalrusProperties.CopyHeaders header : WalrusProperties.CopyHeaders.values()) {
                                if (key.replaceAll("-", "").equals(header.toString().toLowerCase())) {
                                    String value = caseInsensitiveHeaders.get(key);
                                    parseExtendedHeaders(operationParams, header.toString(), value);
                                }
                            }
                        }
                    } else {
                        throw new EucalyptusCloudException("Malformed COPY request");
                    }

                } else {
                    messageContext.setProperty(WalrusProperties.STREAMING_HTTP_PUT, Boolean.TRUE);
                    InputStream in = (InputStream) messageContext.getProperty("TRANSPORT_IN");
                    InputStream inStream = in;
                    if ((!walrusInternalOperation) || (!WalrusProperties.StorageOperations.StoreSnapshot
                            .toString().equals(operationName))) {
                        inStream = new BufferedInputStream(in);
                    } else {
                        try {
                            inStream = new GZIPInputStream(in);
                        } catch (Exception ex) {
                            LOG.warn(ex, ex);
                            throw new EucalyptusCloudException("cannot process input");
                        }
                    }
                    String key = target[0] + "." + objectKey;
                    String randomKey = key + "." + Hashes.getRandom(10);
                    LinkedBlockingQueue<WalrusDataMessage> putQueue = getWriteMessenger()
                            .interruptAllAndGetQueue(key, randomKey);

                    Writer writer = new Writer(inStream, contentLength, putQueue);
                    writer.start();

                    operationParams.put("ContentLength", (new Long(contentLength).toString()));
                    operationParams.put(WalrusProperties.Headers.RandomKey.toString(), randomKey);
                }
            } else if (verb.equals(HTTPVerb.GET.toString())) {
                messageContext.setProperty(WalrusProperties.STREAMING_HTTP_GET, Boolean.TRUE);
                if (!walrusInternalOperation) {

                    operationParams.put("GetData", Boolean.TRUE);
                    operationParams.put("InlineData", Boolean.FALSE);
                    operationParams.put("GetMetaData", Boolean.TRUE);

                    Iterator<String> iterator = caseInsensitiveHeaders.keySet().iterator();
                    boolean isExtendedGet = false;
                    while (iterator.hasNext()) {
                        String key = iterator.next();
                        for (WalrusProperties.ExtendedGetHeaders header : WalrusProperties.ExtendedGetHeaders
                                .values()) {
                            if (key.replaceAll("-", "").equals(header.toString().toLowerCase())) {
                                String value = caseInsensitiveHeaders.get(key);
                                isExtendedGet = true;
                                parseExtendedHeaders(operationParams, header.toString(), value);
                            }
                        }

                    }
                    if (isExtendedGet) {
                        operationKey += "extended";
                        //only supported through SOAP
                        operationParams.put("ReturnCompleteObjectOnConditionFailure", Boolean.FALSE);
                    }
                } else {
                    for (WalrusProperties.InfoOperations operation : WalrusProperties.InfoOperations.values()) {
                        if (operation.toString().equals(operationName)) {
                            messageContext.removeProperty(WalrusProperties.STREAMING_HTTP_GET);
                            break;
                        }
                    }
                }
                if (params.containsKey(WalrusProperties.GetOptionalParameters.IsCompressed.toString())) {
                    Boolean isCompressed = Boolean.parseBoolean(
                            params.remove(WalrusProperties.GetOptionalParameters.IsCompressed.toString()));
                    operationParams.put("IsCompressed", isCompressed);
                }

            } else if (verb.equals(HTTPVerb.HEAD.toString())) {
                messageContext.setProperty(WalrusProperties.STREAMING_HTTP_GET, Boolean.FALSE);
                if (!walrusInternalOperation) {
                    operationParams.put("GetData", Boolean.FALSE);
                    operationParams.put("InlineData", Boolean.FALSE);
                    operationParams.put("GetMetaData", Boolean.TRUE);
                }
            }
        }

    }

    if (verb.equals(HTTPVerb.PUT.toString()) && params.containsKey(OperationParameter.acl.toString())) {
        //read ACL
        InputStream in = (InputStream) messageContext.getProperty("TRANSPORT_IN");
        operationParams.put("AccessControlPolicy", getAccessControlPolicy(in));
    }

    ArrayList paramsToRemove = new ArrayList();

    boolean addMore = true;
    Iterator iterator = params.keySet().iterator();
    while (iterator.hasNext()) {
        Object key = iterator.next();
        String keyString = key.toString().toLowerCase();
        boolean dontIncludeParam = false;
        for (HMACQuerySecurityHandler.SecurityParameter securityParam : HMACQuerySecurityHandler.SecurityParameter
                .values()) {
            if (keyString.equals(securityParam.toString().toLowerCase())) {
                dontIncludeParam = true;
                break;
            }
        }
        if (dontIncludeParam)
            continue;
        String value = params.get(key);
        if (value != null) {
            String[] keyStringParts = keyString.split("-");
            if (keyStringParts.length > 1) {
                keyString = "";
                for (int i = 0; i < keyStringParts.length; ++i) {
                    keyString += toUpperFirst(keyStringParts[i]);
                }
            } else {
                keyString = toUpperFirst(keyString);
            }
            operationParams.put(keyString, value);
        }
        if (addMore) {
            //just add the first one to the key
            operationKey += keyString.toLowerCase();
            addMore = false;
        }
        paramsToRemove.add(key);
    }

    for (Object key : paramsToRemove) {
        params.remove(key);
    }

    if (!walrusInternalOperation) {
        operationName = operationMap.get(operationKey);
    }
    httpRequest.setBindingArguments(operationParams);
    messageContext.setProperty(WalrusProperties.WALRUS_OPERATION, operationName);
    return operationName;
}

From source file:com.uniquesoft.uidl.servlet.UploadServlet.java

/**
 * Get an uploaded file item./*from w  ww.  ja  v a 2 s .com*/
 * 
 * @param request
 * @param response
 * @throws IOException
 */
public void getUploadedFile(HttpServletRequest request, HttpServletResponse response) throws IOException {
    String parameter = request.getParameter(UConsts.PARAM_SHOW);
    FileItem item = findFileItem(getMySessionFileItems(request), parameter);
    if (item != null) {
        logger.debug("UPLOAD-SERVLET (" + request.getSession().getId() + ") getUploadedFile: " + parameter
                + " returning: " + item.getContentType() + ", " + item.getName() + ", " + item.getSize()
                + " bytes");
        response.setContentType(item.getContentType());
        copyFromInputStreamToOutputStream(item.getInputStream(), response.getOutputStream());
    } else {
        logger.info("UPLOAD-SERVLET (" + request.getSession().getId() + ") getUploadedFile: " + parameter
                + " file isn't in session.");
        renderXmlResponse(request, response, XML_ERROR_ITEM_NOT_FOUND);
    }
}

From source file:com.nabla.wapp.server.basic.general.ImportService.java

@Override
public String executeAction(final HttpServletRequest request, final List<FileItem> sessionFiles)
        throws UploadActionException {
    final UserSession userSession = UserSession.load(request);
    if (userSession == null) {
        if (log.isTraceEnabled())
            log.trace("missing user session");
        throw new UploadActionException("permission denied");
    }/* w w  w  . j ava2  s .c o  m*/
    Assert.state(sessionFiles.size() == 1);
    try {
        for (FileItem file : sessionFiles) {
            if (file.isFormField())
                continue;
            if (log.isDebugEnabled()) {
                log.debug("field '" + file.getFieldName() + "': uploading " + file.getName());
                log.debug("field: " + file.getFieldName());
                log.debug("filename: " + file.getName());
                log.debug("content_type: " + file.getContentType());
                log.debug("size: " + file.getSize());
            }
            final Connection conn = db.getConnection();
            try {
                final PreparedStatement stmt = conn.prepareStatement(
                        "INSERT INTO import_data (field_name, file_name, content_type, length, content, userSessionId) VALUES(?,?,?,?,?,?);",
                        Statement.RETURN_GENERATED_KEYS);
                try {
                    stmt.setString(1, file.getFieldName());
                    stmt.setString(2, file.getName());
                    stmt.setString(3, file.getContentType());
                    stmt.setLong(4, file.getSize());
                    stmt.setString(6, userSession.getSessionId());
                    final InputStream fs = file.getInputStream();
                    try {
                        stmt.setBinaryStream(5, fs);
                        if (stmt.executeUpdate() != 1) {
                            if (log.isErrorEnabled())
                                log.error("failed to add imported file record");
                            throw new UploadActionException("internal error");
                        }
                        final ResultSet rsKey = stmt.getGeneratedKeys();
                        try {
                            rsKey.next();
                            final Integer id = rsKey.getInt(1);
                            if (log.isDebugEnabled())
                                log.debug(
                                        "uploading " + file.getName() + " successfully completed. id = " + id);
                            return id.toString();
                        } finally {
                            rsKey.close();
                        }
                    } finally {
                        fs.close();
                    }
                } catch (IOException e) {
                    if (log.isErrorEnabled())
                        log.error("error reading file " + file.getName(), e);
                    throw new UploadActionException("internal error");
                } finally {
                    Database.close(stmt);
                }
            } finally {
                // remove any orphan import records i.e. older than 48h (beware of timezone!)
                final Calendar dt = Util.dateToCalendar(new Date());
                dt.add(GregorianCalendar.DATE, -2);
                try {
                    Database.executeUpdate(conn, "DELETE FROM import_data WHERE created < ?;",
                            Util.calendarToSqlDate(dt));
                } catch (final SQLException __) {
                }
                Database.close(conn);
            }
        }
    } catch (SQLException e) {
        if (log.isErrorEnabled())
            log.error("error uploading file", e);
        throw new UploadActionException("internal error");
    } finally {
        super.removeSessionFileItems(request);
    }
    return null;
}

From source file:com.exedio.cope.live.Bar.java

void doRequest(final HttpServletRequest request, final HttpSession httpSession,
        final HttpServletResponse response, final Anchor anchor) throws IOException {
    if (!Cop.isPost(request)) {
        try {// w ww .  j  a va 2 s .c o m
            startTransaction("redirectHome");
            anchor.redirectHome(request, response);
            model.commit();
        } finally {
            model.rollbackIfNotCommitted();
        }
        return;
    }

    final String referer;

    if (isMultipartContent(request)) {
        final HashMap<String, String> fields = new HashMap<String, String>();
        final HashMap<String, FileItem> files = new HashMap<String, FileItem>();
        final FileItemFactory factory = new DiskFileItemFactory();
        final ServletFileUpload upload = new ServletFileUpload(factory);
        upload.setHeaderEncoding(UTF_8.name());
        try {
            for (final Iterator<?> i = upload.parseRequest(request).iterator(); i.hasNext();) {
                final FileItem item = (FileItem) i.next();
                if (item.isFormField())
                    fields.put(item.getFieldName(), item.getString(UTF_8.name()));
                else
                    files.put(item.getFieldName(), item);
            }
        } catch (final FileUploadException e) {
            throw new RuntimeException(e);
        }

        final String featureID = fields.get(FEATURE);
        if (featureID == null)
            throw new NullPointerException();

        final Media feature = (Media) model.getFeature(featureID);
        if (feature == null)
            throw new NullPointerException(featureID);

        final String itemID = fields.get(ITEM);
        if (itemID == null)
            throw new NullPointerException();

        final FileItem file = files.get(FILE);

        try {
            startTransaction("publishFile(" + featureID + ',' + itemID + ')');

            final Item item = model.getItem(itemID);

            if (fields.get(PUBLISH_NOW) != null) {
                for (final History history : History.getHistories(item.getCopeType())) {
                    final History.Event event = history.createEvent(item, anchor.getHistoryAuthor(), false);
                    event.createFeature(feature, feature.getName(),
                            feature.isNull(item) ? null
                                    : ("file type=" + feature.getContentType(item) + " size="
                                            + feature.getLength(item)),
                            "file name=" + file.getName() + " type=" + file.getContentType() + " size="
                                    + file.getSize());
                }

                // TODO use more efficient setter with File or byte[]
                feature.set(item, file.getInputStream(), file.getContentType());
            } else {
                anchor.modify(file, feature, item);
            }

            model.commit();
        } catch (final NoSuchIDException e) {
            throw new RuntimeException(e);
        } finally {
            model.rollbackIfNotCommitted();
        }

        referer = fields.get(REFERER);
    } else // isMultipartContent
    {
        if (request.getParameter(BORDERS_ON) != null || request.getParameter(BORDERS_ON_IMAGE) != null) {
            anchor.borders = true;
        } else if (request.getParameter(BORDERS_OFF) != null
                || request.getParameter(BORDERS_OFF_IMAGE) != null) {
            anchor.borders = false;
        } else if (request.getParameter(CLOSE) != null || request.getParameter(CLOSE_IMAGE) != null) {
            httpSession.removeAttribute(LoginServlet.ANCHOR);
        } else if (request.getParameter(SWITCH_TARGET) != null) {
            anchor.setTarget(servlet.getTarget(request.getParameter(SWITCH_TARGET)));
        } else if (request.getParameter(SAVE_TARGET) != null) {
            try {
                startTransaction("saveTarget");
                anchor.getTarget().save(anchor);
                model.commit();
            } finally {
                model.rollbackIfNotCommitted();
            }
            anchor.notifyPublishedAll();
        } else {
            final String featureID = request.getParameter(FEATURE);
            if (featureID == null)
                throw new NullPointerException();

            final Feature featureO = model.getFeature(featureID);
            if (featureO == null)
                throw new NullPointerException(featureID);

            final String itemID = request.getParameter(ITEM);
            if (itemID == null)
                throw new NullPointerException();

            if (featureO instanceof StringField) {
                final StringField feature = (StringField) featureO;
                final String value = request.getParameter(TEXT);

                try {
                    startTransaction("barText(" + featureID + ',' + itemID + ')');

                    final Item item = model.getItem(itemID);

                    if (request.getParameter(PUBLISH_NOW) != null) {
                        String v = value;
                        if ("".equals(v))
                            v = null;
                        for (final History history : History.getHistories(item.getCopeType())) {
                            final History.Event event = history.createEvent(item, anchor.getHistoryAuthor(),
                                    false);
                            event.createFeature(feature, feature.getName(), feature.get(item), v);
                        }
                        feature.set(item, v);
                        anchor.notifyPublished(feature, item);
                    } else {
                        anchor.modify(value, feature, item);
                    }

                    model.commit();
                } catch (final NoSuchIDException e) {
                    throw new RuntimeException(e);
                } finally {
                    model.rollbackIfNotCommitted();
                }
            } else {
                final IntegerField feature = (IntegerField) featureO;
                final String itemIDFrom = request.getParameter(ITEM_FROM);
                if (itemIDFrom == null)
                    throw new NullPointerException();

                try {
                    startTransaction("swapPosition(" + featureID + ',' + itemIDFrom + ',' + itemID + ')');

                    final Item itemFrom = model.getItem(itemIDFrom);
                    final Item itemTo = model.getItem(itemID);

                    final Integer positionFrom = feature.get(itemFrom);
                    final Integer positionTo = feature.get(itemTo);
                    feature.set(itemFrom, feature.getMinimum());
                    feature.set(itemTo, positionFrom);
                    feature.set(itemFrom, positionTo);

                    for (final History history : History.getHistories(itemFrom.getCopeType())) {
                        final History.Event event = history.createEvent(itemFrom, anchor.getHistoryAuthor(),
                                false);
                        event.createFeature(feature, feature.getName(), positionFrom, positionTo);
                    }
                    for (final History history : History.getHistories(itemTo.getCopeType())) {
                        final History.Event event = history.createEvent(itemTo, anchor.getHistoryAuthor(),
                                false);
                        event.createFeature(feature, feature.getName(), positionTo, positionFrom);
                    }

                    model.commit();
                } catch (final NoSuchIDException e) {
                    throw new RuntimeException(e);
                } finally {
                    model.rollbackIfNotCommitted();
                }
            }
        }

        referer = request.getParameter(REFERER);
    }

    if (referer != null)
        response.sendRedirect(response.encodeRedirectURL(referer));
}

From source file:it.lufraproini.cms.servlet.upload_user_img.java

private Map prendiInfoFile(HttpServletRequest request) throws ErroreGrave, IOException {
    Map infofile = new HashMap();
    //riutilizzo codice prof. Della Penna per l'upload
    if (ServletFileUpload.isMultipartContent(request)) {
        // Funzioni delle librerie Apache per l'upload
        try {/*from  ww w.j  a v  a2s. c o  m*/
            FileItemFactory factory = new DiskFileItemFactory();
            ServletFileUpload upload = new ServletFileUpload(factory);
            List<FileItem> items;
            FileItem file = null;

            items = upload.parseRequest(request);
            for (FileItem item : items) {
                String name = item.getFieldName();
                if (name.equals("file_to_upload")) {
                    file = item;
                    break;
                }
            }
            if (file == null || file.getName().equals("")) {
                throw new ErroreGrave("la form non ha inviato il campo file!");
            } else {
                //informazioni
                String nome_e_path = file.getName();
                String estensione = FilenameUtils.getExtension(FilenameUtils.getName(nome_e_path));
                String nome_senza_estensione = FilenameUtils.getBaseName(FilenameUtils.getName(nome_e_path));
                infofile.put("nome_completo", nome_senza_estensione + "." + estensione);
                infofile.put("estensione", estensione);
                infofile.put("nome_senza_estensione", nome_senza_estensione);
                infofile.put("dimensione", file.getSize());
                infofile.put("input_stream", file.getInputStream());
                infofile.put("content_type", file.getContentType());
            }

        } catch (FileUploadException ex) {
            Logger.getLogger(upload_user_img.class.getName()).log(Level.SEVERE, null, ex);
            throw new ErroreGrave("errore libreria apache!");
        }

    }
    return infofile;
}

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;//  w  w w  .j  a v  a 2  s  .  c o  m
    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:edu.cornell.mannlib.vitro.webapp.controller.jena.JenaCsv2RdfController.java

public Model doExecuteCsv2Rdf(VitroRequest vreq, FileItem fileStream, String filePath) throws Exception {
    char[] quoteChars = { '"' };
    String namespace = "";
    String tboxNamespace = vreq.getParameter("tboxNamespace");
    String typeName = vreq.getParameter("typeName");
    String csvUrl = vreq.getParameter("csvUrl");
    Model destination = null;/*from w  ww. j a  v a  2  s .  c om*/
    String destinationModelNameStr = vreq.getParameter("destinationModelName");
    if (destinationModelNameStr != null && destinationModelNameStr.length() > 0) {
        destination = getModel(destinationModelNameStr, vreq);
    }
    Model tboxDestination = null;
    String tboxDestinationModelNameStr = vreq.getParameter("tboxDestinationModelName");
    if (tboxDestinationModelNameStr != null && tboxDestinationModelNameStr.length() > 0) {
        tboxDestination = getModel(tboxDestinationModelNameStr, vreq);
    }

    char separatorChar = ',';
    if ("tab".equalsIgnoreCase(vreq.getParameter("separatorChar"))) {
        separatorChar = '\t';
    }

    Csv2Rdf c2r = new Csv2Rdf(separatorChar, quoteChars, namespace, tboxNamespace, typeName);

    InputStream is = null;

    try {
        if (!csvUrl.isEmpty())
            is = new URL(csvUrl).openStream();
        else if (!filePath.isEmpty())
            is = fileStream.getInputStream();

    } catch (IOException e) {
        throw new Exception("Unable to access URL " + csvUrl);
    }

    Model[] models = null;

    try {
        models = c2r.convertToRdf(is, vreq.getWebappDaoFactory(), destination);
    } catch (IOException e) {
        throw new Exception("Unable to convert " + csvUrl + " to RDF");
    }

    // TODO: rework this
    vreq.getSession().setAttribute("csv2rdfResult", models[0]);
    if (tboxDestination != null) {
        tboxDestination.add(models[1]);
    }

    return models[0];
}