Example #1
0
  private void parseParams() {

    DiskFileItemFactory dff = new DiskFileItemFactory();
    try {
      ServletFileUpload sfu = new ServletFileUpload(dff);
      sfu.setSizeMax(this.maxSize);
      sfu.setHeaderEncoding(Uploader.ENCODEING);

      FileItemIterator fii = sfu.getItemIterator(this.request);

      while (fii.hasNext()) {
        FileItemStream item = fii.next();
        // 普通参数存储
        if (item.isFormField()) {

          this.params.put(item.getFieldName(), this.getParameterValue(item.openStream()));

        } else {

          // 只保留一个
          if (this.inputStream == null) {
            this.inputStream = item.openStream();
            this.originalName = item.getName();
            return;
          }
        }
      }

    } catch (Exception e) {
      this.state = this.errorInfo.get("UNKNOWN");
    }
  }
Example #2
0
 public void upload() throws Exception {
   boolean isMultipart = ServletFileUpload.isMultipartContent(this.request);
   if (!isMultipart) {
     this.state = this.errorInfo.get("NOFILE");
     return;
   }
   DiskFileItemFactory dff = new DiskFileItemFactory();
   String savePath = this.getFolder(this.savePath);
   dff.setRepository(new File(savePath));
   try {
     ServletFileUpload sfu = new ServletFileUpload(dff);
     sfu.setSizeMax(this.maxSize * 1024);
     sfu.setHeaderEncoding("utf-8");
     FileItemIterator fii = sfu.getItemIterator(this.request);
     while (fii.hasNext()) {
       FileItemStream fis = fii.next();
       if (!fis.isFormField()) {
         this.originalName =
             fis.getName()
                 .substring(fis.getName().lastIndexOf(System.getProperty("file.separator")) + 1);
         if (!this.checkFileType(this.originalName)) {
           this.state = this.errorInfo.get("TYPE");
           continue;
         }
         this.fileName = this.getName(this.originalName);
         this.type = this.getFileExt(this.fileName);
         this.url = savePath + "/" + this.fileName;
         BufferedInputStream in = new BufferedInputStream(fis.openStream());
         FileOutputStream out = new FileOutputStream(new File(this.getPhysicalPath(this.url)));
         BufferedOutputStream output = new BufferedOutputStream(out);
         Streams.copy(in, output, true);
         this.state = this.errorInfo.get("SUCCESS");
         // UE中只会处理单张上传,完成后即退出
         break;
       } else {
         String fname = fis.getFieldName();
         // 只处理title,其余表单请自行处理
         if (!fname.equals("pictitle")) {
           continue;
         }
         BufferedInputStream in = new BufferedInputStream(fis.openStream());
         BufferedReader reader = new BufferedReader(new InputStreamReader(in));
         StringBuffer result = new StringBuffer();
         while (reader.ready()) {
           result.append((char) reader.read());
         }
         this.title = new String(result.toString().getBytes(), "utf-8");
         reader.close();
       }
     }
   } catch (SizeLimitExceededException e) {
     this.state = this.errorInfo.get("SIZE");
   } catch (InvalidContentTypeException e) {
     this.state = this.errorInfo.get("ENTYPE");
   } catch (FileUploadException e) {
     this.state = this.errorInfo.get("REQUEST");
   } catch (Exception e) {
     this.state = this.errorInfo.get("UNKNOWN");
   }
 }
  @RvdAuth
  @POST
  @Path("{name}/wavs")
  public Response uploadWavFile(
      @PathParam("name") String projectName, @Context HttpServletRequest request)
      throws StorageException, ProjectDoesNotExist {
    logger.info("running /uploadwav");
    assertProjectAvailable(projectName);
    try {
      if (request.getHeader("Content-Type") != null
          && request.getHeader("Content-Type").startsWith("multipart/form-data")) {
        Gson gson = new Gson();
        ServletFileUpload upload = new ServletFileUpload();
        FileItemIterator iterator = upload.getItemIterator(request);

        JsonArray fileinfos = new JsonArray();

        while (iterator.hasNext()) {
          FileItemStream item = iterator.next();
          JsonObject fileinfo = new JsonObject();
          fileinfo.addProperty("fieldName", item.getFieldName());

          // is this a file part (talking about multipart requests, there might be parts that are
          // not actual files).
          // They will be ignored
          if (item.getName() != null) {
            projectService.addWavToProject(projectName, item.getName(), item.openStream());
            fileinfo.addProperty("name", item.getName());
            // fileinfo.addProperty("size", size(item.openStream()));
          }
          if (item.getName() == null) {
            logger.warn("non-file part found in upload");
            fileinfo.addProperty("value", read(item.openStream()));
          }
          fileinfos.add(fileinfo);
        }

        return Response.ok(gson.toJson(fileinfos), MediaType.APPLICATION_JSON).build();

      } else {

        String json_response = "{\"result\":[{\"size\":" + size(request.getInputStream()) + "}]}";
        return Response.ok(json_response, MediaType.APPLICATION_JSON).build();
      }
    } catch (Exception e /* TODO - use a more specific type !!! */) {
      logger.error(e.getMessage(), e);
      return Response.status(Status.INTERNAL_SERVER_ERROR).build();
    }
  }
Example #4
0
  public void add(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {

    FileItemFactory factory = new DiskFileItemFactory();
    ServletFileUpload upload = new ServletFileUpload(factory);
    FileItemIterator iterator = null;
    try {
      iterator = upload.getItemIterator(request);
      while (iterator.hasNext()) {
        FileItemStream item = iterator.next();
        InputStream in = item.openStream();
        if (item.getFieldName().equals("bundleUpload")) {
          String fname = item.getName();
          if (!fname.endsWith(".jar")) {
            Logger.warn(this, "Cannot deplpy bundle as it is not a JAR");
            writeError(response, "Cannot deplpy bundle as it is not a JAR");
            break;
          }

          File to = new File(Config.CONTEXT.getRealPath("/WEB-INF/felix/load/" + fname));
          FileOutputStream out = new FileOutputStream(to);
          IOUtils.copyLarge(in, out);
          IOUtils.closeQuietly(out);
          IOUtils.closeQuietly(in);
        }
      }
    } catch (FileUploadException e) {
      Logger.error(OSGIBaseAJAX.class, e.getMessage(), e);
      throw new IOException(e.getMessage(), e);
    }
  }
  protected void doPost(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
    super.doPost(request, response);

    try {
      if (!ServletFileUpload.isMultipartContent(request)) {
        response.sendError(HttpServletResponse.SC_BAD_REQUEST);
        return;
      }

      ServletFileUpload sfU = new ServletFileUpload();
      FileItemIterator items = sfU.getItemIterator(request);
      while (items.hasNext()) {
        FileItemStream item = items.next();
        if (!item.isFormField()) {
          InputStream stream = item.openStream();
          Document doc = editor.toDocument(stream);
          stream.close();
          handleDocument(request, response, doc);
          return;
        }
      }

      response.sendError(HttpServletResponse.SC_BAD_REQUEST, "No XML uploaded");
    } catch (FileUploadException fuE) {
      response.sendError(HttpServletResponse.SC_BAD_REQUEST, fuE.getMessage());
    } catch (JDOMException jE) {
      response.sendError(HttpServletResponse.SC_BAD_REQUEST, jE.getMessage());
    }
  }
Example #6
0
 /**
  * Start the Upload of the items
  *
  * @throws Exception
  */
 public void upload() throws Exception {
   UserController uc = new UserController(null);
   user = uc.retrieve(getUser().getEmail());
   HttpServletRequest req =
       (HttpServletRequest) FacesContext.getCurrentInstance().getExternalContext().getRequest();
   boolean isMultipart = ServletFileUpload.isMultipartContent(req);
   if (isMultipart) {
     ServletFileUpload upload = new ServletFileUpload();
     // Parse the request
     FileItemIterator iter = upload.getItemIterator(req);
     while (iter.hasNext()) {
       FileItemStream fis = iter.next();
       InputStream stream = fis.openStream();
       if (!fis.isFormField()) {
         title = fis.getName();
         File tmp = createTmpFile();
         try {
           writeInTmpFile(tmp, stream);
           Item item = uploadFile(tmp);
           if (item != null) itemList.add(item);
         } finally {
           stream.close();
           FileUtils.deleteQuietly(tmp);
         }
       }
     }
   }
 }
  /**
   * Parses the input stream.
   *
   * @param request the request
   * @param response the response
   * @return the byte array output stream
   * @throws ServletException the servlet exception
   * @throws IOException Signals that an I/O exception has occurred.
   */
  public ByteArrayOutputStream parseInputStream(
      HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
    ServletFileUpload upload = new ServletFileUpload();
    ByteArrayOutputStream out = new ByteArrayOutputStream();

    try {
      FileItemIterator iter = upload.getItemIterator(request);
      while (iter.hasNext()) {
        FileItemStream item = iter.next();
        InputStream stream = item.openStream();
        // Process the input stream
        int len;
        byte[] buffer = new byte[8192];
        while ((len = stream.read(buffer, 0, buffer.length)) != -1) {
          out.write(buffer, 0, len);
        }

        int maxFileSize = 10 * (1024 * 1024); // 10 megs max
        if (out.size() > maxFileSize) {
          response.sendError(
              HttpServletResponse.SC_REQUEST_ENTITY_TOO_LARGE, "Max allowed file size: 10 Mb");
        }
      }
    } catch (Exception e) {
      e.printStackTrace();
    }

    return out;
  }
Example #8
0
  private void upload(HttpServletRequest req, HttpServletResponse res)
      throws ServletException, IOException {
    try {
      res.setContentType("text/plain");

      ServletFileUpload upload = new ServletFileUpload();
      FileItemIterator iterator = upload.getItemIterator(req);
      while (iterator.hasNext()) {
        FileItemStream item = iterator.next();
        InputStream stream = item.openStream();

        if (item.isFormField()) {
          log.warning("Got a form field: " + item.getFieldName());
        } else {
          log.warning(
              "Got an uploaded file: " + item.getFieldName() + ", name = " + item.getName());

          // You now have the filename (item.getName() and the
          // contents (which you can read from stream).  Here we just
          // print them back out to the servlet output stream, but you
          // will probably want to do something more interesting (for
          // example, wrap them in a Blob and commit them to the
          // datastore).
          int len;
          byte[] buffer = new byte[8192];
          while ((len = stream.read(buffer, 0, buffer.length)) != -1) {
            res.getOutputStream().write(buffer, 0, len);
          }
        }
      }
    } catch (Exception ex) {
      throw new ServletException(ex);
    }
  }
  @Override
  protected void doPost(HttpServletRequest request, HttpServletResponse resp)
      throws ServletException, IOException {
    boolean isMultipart = ServletFileUpload.isMultipartContent(request);

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

    // Parse the request
    FileItemIterator iter;
    try {
      iter = upload.getItemIterator(request);

      while (iter.hasNext()) {
        FileItemStream item = iter.next();
        String name = item.getFieldName();
        InputStream stream = item.openStream();
        if (item.isFormField()) {
          System.out.println(
              "Form field " + name + " with value " + Streams.asString(stream) + " detected.");
        } else {
          System.out.println(
              "File field " + name + " with file name " + item.getName() + " detected.");
          // Process the input stream
          int read = 0;
          final byte[] bytes = new byte[1024];
          FileOutputStream fileOut = new FileOutputStream(new File(item.getName()));
          while ((read = stream.read(bytes)) != -1) {
            System.out.println("read " + read + " bytes");
            fileOut.write(bytes, 0, read);
          }
          stream.close();
          fileOut.close();
        }
      }
    } catch (FileUploadException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }

    //		final Part filePart = req.getPart("file");
    //	    int read = 0;
    //        final byte[] bytes = new byte[1024];
    //        InputStream filecontent = filePart.getInputStream();
    //	    final String fileName = getFileName(filePart);
    //        FileOutputStream fileOut = new FileOutputStream(new File(fileName));
    //        while ((read = filecontent.read(bytes)) != -1) {
    //            System.out.println("read " + read + " bytes");
    //            fileOut.write(bytes, 0, read);
    //        }
    //        filecontent.close();
    //        fileOut.close();

  }
  /**
   * Parse request parameters and files.
   *
   * @param request
   * @param response
   */
  protected void parseRequest(HttpServletRequest request, HttpServletResponse response) {
    requestParams = new HashMap<String, Object>();
    listFiles = new ArrayList<FileItemStream>();
    listFileStreams = new ArrayList<ByteArrayOutputStream>();

    // Parse the request
    if (ServletFileUpload.isMultipartContent(request)) {
      // multipart request
      try {
        ServletFileUpload upload = new ServletFileUpload();
        FileItemIterator iter = upload.getItemIterator(request);
        while (iter.hasNext()) {
          FileItemStream item = iter.next();
          String name = item.getFieldName();
          InputStream stream = item.openStream();
          if (item.isFormField()) {
            requestParams.put(name, Streams.asString(stream));
          } else {
            String fileName = item.getName();
            if (fileName != null && !"".equals(fileName.trim())) {
              listFiles.add(item);

              ByteArrayOutputStream os = new ByteArrayOutputStream();
              IOUtils.copy(stream, os);
              listFileStreams.add(os);
            }
          }
        }
      } catch (Exception e) {
        logger.error("Unexpected error parsing multipart content", e);
      }
    } else {
      // not a multipart
      for (Object mapKey : request.getParameterMap().keySet()) {
        String mapKeyString = (String) mapKey;

        if (mapKeyString.endsWith("[]")) {
          // multiple values
          String values[] = request.getParameterValues(mapKeyString);
          List<String> listeValues = new ArrayList<String>();
          for (String value : values) {
            listeValues.add(value);
          }
          requestParams.put(mapKeyString, listeValues);
        } else {
          // single value
          String value = request.getParameter(mapKeyString);
          requestParams.put(mapKeyString, value);
        }
      }
    }
  }
Example #11
0
 private void receive(FileItemStream item) throws IOException {
   InputStream stream = item.openStream();
   try {
     String fileName = stripFileName(item.getName());
     String contentType = item.getContentType();
     FileDetails details = new FileDetailsImpl(fileName, contentType);
     FileUploadReceiver receiver = handler.getReceiver();
     receiver.receive(stream, details);
     tracker.addFile(details);
   } finally {
     stream.close();
   }
 }
  private void parseMultipartData(RestServiceRequest rsr, IMendixObject argO, JSONObject data)
      throws IOException, FileUploadException {
    boolean hasFile = false;

    for (FileItemIterator iter = servletFileUpload.getItemIterator(rsr.request); iter.hasNext(); ) {
      FileItemStream item = iter.next();
      if (!item.isFormField()) { // This is the file(?!)
        if (!isFileSource) {
          RestServices.LOGPUBLISH.warn(
              "Received request with binary data but input argument isn't a filedocument. Skipping. At: "
                  + rsr.request.getRequestURL().toString());
          continue;
        }
        if (hasFile)
          RestServices.LOGPUBLISH.warn(
              "Received request with multiple files. Only one is supported. At: "
                  + rsr.request.getRequestURL().toString());
        hasFile = true;
        Core.storeFileDocumentContent(
            rsr.getContext(), argO, determineFileName(item), item.openStream());
      } else data.put(item.getFieldName(), IOUtils.toString(item.openStream()));
    }
  }
Example #13
0
 private HashMap<String, Blob> getShipImgs(HttpServletRequest req) throws IOException {
   HashMap<String, Blob> images = new HashMap<String, Blob>();
   ServletFileUpload upload = new ServletFileUpload();
   try {
     FileItemIterator iterator = upload.getItemIterator(req);
     while (iterator.hasNext()) {
       FileItemStream item = iterator.next();
       InputStream stream = item.openStream();
       if (!item.isFormField()
           && ("shipIcon".equals(item.getFieldName()) || "ship256".equals(item.getFieldName()))) {
         images.put(item.getFieldName(), new Blob(IOUtils.toByteArray(stream)));
       }
     }
   } catch (FileUploadException e) {
     log.log(Level.SEVERE, "Ship img error", e);
   }
   return images;
 }
Example #14
0
  public static boolean processFile(String path, FileItemStream item) {
    try {
      File f = new File(path + File.separator + "images");
      if (!f.exists()) f.mkdir();
      File savedFile = new File(f.getAbsolutePath() + File.separator + item.getName());
      FileOutputStream fos = new FileOutputStream(savedFile);
      InputStream is = item.openStream();

      int x = 0;
      byte[] b = new byte[1024];
      while ((x = is.read(b)) != -1) {
        fos.write(b, 0, x);
      }
      fos.flush();
      fos.close();
      return true;
    } catch (IOException e) {
    }
    return false;
  }
Example #15
0
  @POST
  @Path("port")
  @Consumes(MediaType.MULTIPART_FORM_DATA)
  public void importData(@Context HttpServletRequest request) throws IcatException, IOException {
    if (!ServletFileUpload.isMultipartContent(request)) {
      throw new IcatException(IcatExceptionType.BAD_PARAMETER, "Multipart content expected");
    }

    ServletFileUpload upload = new ServletFileUpload();
    String jsonString = null;
    String name = null;

    // Parse the request
    try {
      FileItemIterator iter = upload.getItemIterator(request);
      while (iter.hasNext()) {
        FileItemStream item = iter.next();
        String fieldName = item.getFieldName();
        InputStream stream = item.openStream();
        if (item.isFormField()) {
          String value = Streams.asString(stream);
          if (fieldName.equals("json")) {
            jsonString = value;
          } else {
            throw new IcatException(
                IcatExceptionType.BAD_PARAMETER, "Form field " + fieldName + "is not recognised");
          }
        } else {
          if (name == null) {
            name = item.getName();
          }
          porter.importData(jsonString, stream, manager, userTransaction);
        }
      }
    } catch (FileUploadException e) {
      throw new IcatException(IcatExceptionType.INTERNAL, e.getClass() + " " + e.getMessage());
    }
  }
Example #16
0
  /**
   * Get the reader for the identifiers uploaded with this request.
   *
   * @param request The request object.
   * @return A buffered reader for reading the identifiers.
   */
  protected BufferedReader getReader(final HttpServletRequest request) {
    BufferedReader r = null;

    if (ServletFileUpload.isMultipartContent(request)) {
      final ServletFileUpload upload = new ServletFileUpload();
      try {
        final FileItemIterator iter = upload.getItemIterator(request);
        while (iter.hasNext()) {
          final FileItemStream item = iter.next();
          final String fieldName = item.getFieldName();
          if (!item.isFormField() && "identifiers".equalsIgnoreCase(fieldName)) {
            final InputStream stream = item.openStream();
            final InputStreamReader in = new InputStreamReader(stream);
            r = new BufferedReader(in);
            break;
          }
        }
      } catch (FileUploadException e) {
        throw new ServiceException("Could not read request body", e);
      } catch (IOException e) {
        throw new ServiceException(e);
      }
    } else {
      if (!requestIsOfSuitableType()) {
        throw new BadRequestException("Bad content type - " + request.getContentType() + USAGE);
      }
      try {
        r = request.getReader();
      } catch (IOException e) {
        throw new ServiceException(e);
      }
    }
    if (r == null) {
      throw new BadRequestException("No identifiers found in request." + USAGE);
    }
    return r;
  }
  /**
   * A Helper method which assert whether the HTTP content received in the HTTP monitor is a
   * multi-part form data, with basic-auth and well-formed partnership operation request.
   */
  private void assertHttpRequestReceived() throws Exception {
    // Debug print information.
    Map headers = monitor.getHeaders();

    // #0 Assertion
    assertFalse("No HTTP header found in the captured data.", headers.isEmpty());

    Map.Entry tmp = null;
    Iterator itr = null;
    itr = headers.entrySet().iterator();
    logger.info("Header information");
    while (itr.hasNext()) {
      tmp = (Map.Entry) itr.next();
      logger.info(tmp.getKey() + " : " + tmp.getValue());
    }

    // #1 Check BASIC authentication value.
    String basicAuth = (String) headers.get("Authorization");

    // #1 Assertion
    assertNotNull("No Basic Authentication found in the HTTP Header.", basicAuth);

    String[] authToken = basicAuth.split(" ");

    // There are 2 token, one is the "Basic" and another is the base64 auth value.
    assertTrue(authToken.length == 2);
    assertTrue("Missing basic auth prefix 'Basic'", authToken[0].equalsIgnoreCase("Basic"));
    // #1 Decode the base64 authentication value to see whether it is "corvus:corvus".
    String decodedCredential = new String(new BASE64Decoder().decodeBuffer(authToken[1]), "UTF-8");
    assertEquals("Invalid basic auth content", USER_NAME + ":" + PASSWORD, decodedCredential);

    // #2 Check content Type
    String contentType = monitor.getContentType();
    String mediaType = contentType.split(";")[0];
    assertEquals("Invalid content type", "multipart/form-data", mediaType);

    // #3 Check the multi-part content.
    // Make a request context that bridge the content from our monitor to FileUpload library.
    RequestContext rc =
        new RequestContext() {
          public String getCharacterEncoding() {
            return "charset=ISO-8859-1";
          }

          public int getContentLength() {
            return monitor.getContentLength();
          }

          public String getContentType() {
            return monitor.getContentType();
          }

          public InputStream getInputStream() {
            return monitor.getInputStream();
          }
        };

    FileUpload multipartParser = new FileUpload();
    FileItemIterator item = multipartParser.getItemIterator(rc);
    FileItemStream fstream = null;

    /*
     * For each field in the partnership, we have to check the existence of the
     * associated field in the HTTP request. Also we check whether the content
     * of that web form field has same data to the field in the partnership.
     */
    itr = this.target.getPartnershipMapping().entrySet().iterator();
    Map data = ((KVPairData) this.target.properties).getProperties();
    Map.Entry e; // an entry representing the partnership data to web form name mapping.
    String formParamName; // a temporary pointer pointing to the value in the entry.
    Object dataValue; // a temporary pointer pointing to the value in the partnership data.

    while (itr.hasNext()) {
      e = (Map.Entry) itr.next();
      formParamName = (String) e.getValue();
      // Add new part if the mapped key is not null.
      if (formParamName != null) {
        assertTrue("Insufficient number of web form parameter hit.", item.hasNext());
        // Get the next multi-part element.
        fstream = item.next();
        // Assert field name
        assertEquals("Missed web form parameter ?", formParamName, fstream.getFieldName());
        // Assert field content
        dataValue = data.get(e.getKey());
        if (dataValue instanceof String) {
          // Assert content equal.
          assertEquals((String) dataValue, IOHandler.readString(fstream.openStream(), null));
        } else if (dataValue instanceof byte[]) {
          byte[] expectedBytes = (byte[]) dataValue;
          byte[] actualBytes = IOHandler.readBytes(fstream.openStream());
          // Assert byte length equal
          assertEquals(expectedBytes.length, actualBytes.length);
          for (int j = 0; j < expectedBytes.length; j++)
            assertEquals(expectedBytes[j], actualBytes[j]);
        } else {
          throw new IllegalArgumentException("Invalid content found in multipart.");
        }
        // Log information.
        logger.info(
            "Field name found and verifed: "
                + fstream.getFieldName()
                + " content type:"
                + fstream.getContentType());
      }
    }
    /* Check whether the partnership operation in the HTTP request is expected as i thought */
    assertTrue("Missing request_action ?!", item.hasNext());
    fstream = item.next();
    assertEquals("request_action", fstream.getFieldName());
    // Assert the request_action has same content the operation name.
    Map partnershipOpMap = this.target.getPartnershipOperationMapping();
    assertEquals(
        partnershipOpMap.get(new Integer(this.target.getExecuteOperation())),
        IOHandler.readString(fstream.openStream(), null));
  }
Example #18
0
  public static final State save(HttpServletRequest request, Map<String, Object> conf) {
    FileItemStream fileStream = null;
    boolean isAjaxUpload = request.getHeader("X_Requested_With") != null;

    if (!ServletFileUpload.isMultipartContent(request)) {
      return new BaseState(false, AppInfo.NOT_MULTIPART_CONTENT);
    }

    ServletFileUpload upload = new ServletFileUpload(new DiskFileItemFactory());

    if (isAjaxUpload) {
      upload.setHeaderEncoding("UTF-8");
    }

    try {
      FileItemIterator iterator = upload.getItemIterator(request);

      while (iterator.hasNext()) {
        fileStream = iterator.next();

        if (!fileStream.isFormField()) break;
        fileStream = null;
      }

      if (fileStream == null) {
        return new BaseState(false, AppInfo.NOTFOUND_UPLOAD_DATA);
      }

      String savePath = (String) conf.get("savePath");
      String originFileName = fileStream.getName();
      String suffix = FileType.getSuffixByFilename(originFileName);

      originFileName = originFileName.substring(0, originFileName.length() - suffix.length());
      savePath = savePath + suffix;

      long maxSize = ((Long) conf.get("maxSize")).longValue();

      if (!validType(suffix, (String[]) conf.get("allowFiles"))) {
        return new BaseState(false, AppInfo.NOT_ALLOW_FILE_TYPE);
      }

      savePath = PathFormat.parse(savePath, originFileName);

      String physicalPath = (String) conf.get("rootPath") + savePath;

      InputStream is = fileStream.openStream();
      State storageState = StorageManager.saveFileByInputStream(is, physicalPath, maxSize);
      is.close();

      if (storageState.isSuccess()) {
        storageState.putInfo("url", PathFormat.format(savePath));
        storageState.putInfo("type", suffix);
        storageState.putInfo("original", originFileName + suffix);
      }

      return storageState;
    } catch (FileUploadException e) {
      return new BaseState(false, AppInfo.PARSE_REQUEST_ERROR);
    } catch (IOException e) {
    }
    return new BaseState(false, AppInfo.IO_ERROR);
  }
  public void doPost(HttpServletRequest req, HttpServletResponse res)
      throws ServletException, IOException {
    try {
      ServletFileUpload upload = new ServletFileUpload();
      res.setContentType("text/plain");

      KanjiDao dao = new KanjiDao();

      FileItemIterator iterator = upload.getItemIterator(req);
      while (iterator.hasNext()) {
        FileItemStream item = iterator.next();
        InputStream stream = item.openStream();

        if (item.isFormField()) {
          log.warning("Got a form field: " + item.getFieldName());
        } else {
          log.info("Got an uploaded file: " + item.getFieldName() + ", name = " + item.getName());

          KanjSvgParser parser = new KanjSvgParser(stream);
          Kanji kanji = parser.parse();
          if (kanji == null) {
            log.warning("Could not parse SVG");
            continue;
          }

          PersistenceManager pm = PMF.get().getPersistenceManager();
          try {
            Kanji existing = dao.findKanji(pm, kanji.getUnicodeNumber());
            if (existing == null) {
              log.warning(
                  String.format("Kanji %s not found. Nothing to update", kanji.getUnicodeNumber()));
              continue;
            }

            List<Stroke> newStrokes = kanji.getStrokes();
            List<Stroke> existingStrokes = existing.getStrokes();
            for (int i = 0; i < existingStrokes.size(); i++) {
              Stroke s = newStrokes.get(i);
              Stroke old = existingStrokes.get(i);
              log.info("old stroke: " + old);
              log.info("new stroke: " + s);

              old.setPath(s.getPath());
              old.setNumber(s.getNumber());
            }

            log.info(
                String.format(
                    "Updated strokes for %s(%s)",
                    existing.getMidashi(), existing.getUnicodeNumber()));
            log.info(String.format("Removing %s from cache", existing.getUnicodeNumber()));
            CacheController.remove(existing.getUnicodeNumber());
          } finally {
            pm.close();
          }
        }

        res.sendRedirect("/update-strokes.xhtml");
      }
    } catch (Exception ex) {
      throw new ServletException(ex);
    }
  }
Example #20
0
  // uplaod api
  @Override
  @POST
  @Path("/upload")
  @Consumes(MediaType.MULTIPART_FORM_DATA)
  @Produces(MediaType.APPLICATION_XML)
  @Transactional(propagation = Propagation.NESTED)
  public Response saveImage(@Context HttpServletRequest request) {

    String comment = null;
    // Token tokenObj = (Token) request.getAttribute("token");
    // byte[] image = null;
    InputStream is = null;
    BufferedOutputStream out = null;
    String path = null;

    try {

      ServletFileUpload servletFileUpload = new ServletFileUpload();
      FileItemIterator fileItemIterator = servletFileUpload.getItemIterator(request);
      while (fileItemIterator.hasNext()) {

        FileItemStream fileItemStream = fileItemIterator.next();
        if ("comment".equals(fileItemStream.getFieldName())) {

          StringWriter stringWriter = new StringWriter();
          IOUtils.copy(fileItemStream.openStream(), stringWriter, "utf-8");
          comment = stringWriter.toString();
        } else if ("content".equals(fileItemStream.getFieldName())) {

          path = createPath();

          // save image content
          // path = ("/Users/aoden/Desktop/aaaaaa.jpg");
          is = fileItemStream.openStream();
          out = new BufferedOutputStream(new FileOutputStream(path));
          int data = -1;
          while ((data = is.read()) != -1) {

            out.write(data);
          }
        }
      }

      Token tokenObj = (Token) request.getAttribute("token");
      Photo photo = new Photo();
      photo.setComment(comment);
      photo.setPath(path);
      photo.setUser(tokenObj.getUser());
      photoDao.save(photo);
      return Response.status(500).entity(buildDTO(200, null)).build();
      // User user = tokenObj.getUser();

    } catch (HibernateException e) {

      e.printStackTrace();
      return Response.status(500).entity(buildDTO(500, null)).build();
    } catch (FileUploadException e) {

      e.printStackTrace();
      return Response.status(500).entity(buildDTO(500, null)).build();
    } catch (IOException e) {

      e.printStackTrace();
      return Response.status(500).entity(buildDTO(500, null)).build();
    } catch (NoSuchAlgorithmException e) {

      e.printStackTrace();
      return Response.status(500).entity(buildDTO(500, null)).build();
    } finally {
      // close the streams
      if (is != null)
        try {
          is.close();
        } catch (IOException e) {

          e.printStackTrace();
        }
      if (out != null)
        try {
          out.close();
        } catch (IOException e) {

          e.printStackTrace();
        }
    }
  }
  protected void handlePost(
      PageContext pageContext, Template template, VelocityContext templateContext)
      throws ServletException, IOException {
    IDAOSession f;
    IMailSender mailSender;
    String submissionHash;
    try {
      DAOFactory df = (DAOFactory) FactoryRegistrar.getFactory(DAOFactory.class);
      MailFactory mf = (MailFactory) FactoryRegistrar.getFactory(MailFactory.class);
      f = df.getInstance();
      mailSender = mf.getInstance();
      submissionHash = df.getSubmissionHashSalt();
    } catch (FactoryException e) {
      throw new ServletException("dao init error", e);
    }

    Assignment assignment = null;

    // Get the assignment
    String assignmentString = pageContext.getParameter("assignment");
    if (assignmentString == null) {
      throw new ServletException("No assignment parameter given");
    }
    Long assignmentId = Long.valueOf(pageContext.getParameter("assignment"));

    Collection<String> fileNames = null;

    // Render page
    try {
      f.beginTransaction();

      IAssignmentDAO assignmentDao = f.getAssignmentDAOInstance();
      IStudentInterfaceQueriesDAO studentInterfaceQueriesDAO =
          f.getStudentInterfaceQueriesDAOInstance();
      assignment = assignmentDao.retrievePersistentEntity(assignmentId);

      if (!studentInterfaceQueriesDAO.isStudentModuleAccessAllowed(
          pageContext.getSession().getPersonBinding().getId(), assignment.getModuleId())) {
        f.abortTransaction();
        throw new DAOException("permission denied (not on module)");
      }

      if (!studentInterfaceQueriesDAO.isStudentAllowedToSubmit(
          pageContext.getSession().getPersonBinding().getId(), assignmentId)) {
        f.abortTransaction();
        throw new DAOException("permission denied (after deadline)");
      }

      templateContext.put("assignment", assignment);
      fileNames = assignmentDao.fetchRequiredFilenames(assignmentId);

      f.endTransaction();
    } catch (DAOException e) {
      f.abortTransaction();
      throw new ServletException("dao exception", e);
    }

    // Create resource.
    Long resourceId = null;
    Resource resource = new Resource();
    resource.setTimestamp(new Date());
    resource.setFilename(
        pageContext.getSession().getPersonBinding().getUniqueIdentifier()
            + "-"
            + assignmentId
            + "-"
            + resource.getTimestamp().getTime()
            + ".zip");
    resource.setMimeType("application/zip");

    try {
      f.beginTransaction();
      IResourceDAO resourceDao = f.getResourceDAOInstance();
      resourceId = resourceDao.createPersistentCopy(resource);
      f.endTransaction();
    } catch (DAOException e) {
      f.abortTransaction();
      throw new ServletException("dao exception", e);
    }

    // Handle upload form
    String securityCode = null;

    OutputStream resourceStream = null;
    ZipOutputStream resourceZipStream = null;

    MessageDigest digest = null;
    HashSet<String> remainingFiles = new HashSet<String>(fileNames);
    HashSet<String> omittedFiles = new HashSet<String>();

    // Begin storing upload
    try {
      f.beginTransaction();
      IResourceDAO resourceDao = f.getResourceDAOInstance();

      digest = MessageDigest.getInstance("MD5");
      resourceStream = resourceDao.openOutputStream(resourceId);
      resourceZipStream = new ZipOutputStream(resourceStream);

      FileItemIterator fileIterator = pageContext.getUploadedFiles();

      // Next item in the form.
      while (fileIterator.hasNext()) {
        FileItemStream currentUpload = fileIterator.next();

        // An actual file?
        if (fileNames.contains(currentUpload.getFieldName())) {
          String filename =
              pageContext.getSession().getPersonBinding().getUniqueIdentifier()
                  + "/"
                  + currentUpload.getFieldName();
          InputStream is = currentUpload.openStream();

          try {
            byte buffer[] = new byte[1024];
            int nread = -1;
            long total = 0;

            // Try to read _one_ byte to see if we have an entry.
            nread = is.read(buffer, 0, 1);

            // Read the rest if there was something
            if (nread == 1) {
              resourceZipStream.putNextEntry(new ZipEntry(filename));

              // Put the initial byte
              resourceZipStream.write(buffer, 0, nread);
              digest.update(buffer, 0, nread);

              // Continue writing
              while ((nread = is.read(buffer)) != -1) {
                total += nread;
                resourceZipStream.write(buffer, 0, nread);
                digest.update(buffer, 0, nread);
              }

              resourceZipStream.closeEntry();
              remainingFiles.remove(currentUpload.getFieldName());
              pageContext.log(Level.INFO, "Student uploaded: " + currentUpload.getFieldName());
            }

            // Done with this entry
            is.close();
          } catch (IOException e) {
            throw new DAOException("IO error returning file stream", e);
          }
        }
        // Omitted a file?
        else if (currentUpload.getFieldName().equals("omit")) {
          BufferedReader reader =
              new BufferedReader(new InputStreamReader(currentUpload.openStream()));
          String fileName = reader.readLine();
          omittedFiles.add(fileName);
          reader.close();
          pageContext.log(Level.INFO, "Student omitted: " + fileName);
        }
      }

      // No files uploaded
      if (omittedFiles.equals(fileNames)) {
        pageContext.log(Level.ERROR, "Student tried to upload nothing!");
        resourceStream.close();
        pageContext.performRedirect(
            pageContext.getPageUrl("student", "submit")
                + "?assignment="
                + assignmentId
                + "&missing=true");
        resourceDao.deletePersistentEntity(resourceId);
        f.endTransaction();
        return;
      }

      // Check for missing files not omitted
      if (!remainingFiles.isEmpty()) {
        for (String fileName : remainingFiles) {
          if (!omittedFiles.contains(fileName)) {
            pageContext.log(
                Level.ERROR, "Student didn't upload " + fileName + " but didn't omit it!");
            resourceStream.close();
            pageContext.performRedirect(
                pageContext.getPageUrl("student", "submit")
                    + "?assignment="
                    + assignmentId
                    + "&missing=true");
            resourceDao.deletePersistentEntity(resourceId);
            f.endTransaction();
            return;
          }
        }
      }

      // Finalize the resource.
      resourceZipStream.flush();
      resourceStream.flush();

      resourceZipStream.close();
      resourceStream.close();

      // Finalise the security code.
      securityCode = byteArrayToHexString(digest.digest());

      f.endTransaction();
    } catch (Exception e) {
      resourceStream.close();
      f.abortTransaction();

      try {
        f.beginTransaction();

        IResourceDAO resourceDao = f.getResourceDAOInstance();
        resourceDao.deletePersistentEntity(resourceId);

        f.endTransaction();
      } catch (DAOException e2) {
        throw new ServletException(
            "error storing upload - additional error cleaning stale resource " + resourceId, e);
      }

      throw new ServletException("error storing upload", e);
    }

    // Salt security code, SHA256 it.
    securityCode = securityCode + submissionHash;

    try {
      digest = MessageDigest.getInstance("SHA-256");
      securityCode = byteArrayToHexString(digest.digest(securityCode.getBytes("UTF-8")));
    } catch (Exception e) {
      f.abortTransaction();

      try {
        f.beginTransaction();

        IResourceDAO resourceDao = f.getResourceDAOInstance();
        resourceDao.deletePersistentEntity(resourceId);

        f.endTransaction();
      } catch (DAOException e2) {
        throw new ServletException(
            "error hashing - additional error cleaning stale resource " + resourceId, e);
      }

      throw new ServletException("error hashing", e);
    }

    // Create the submission.
    Submission submission = new Submission();
    submission.setPersonId(pageContext.getSession().getPersonBinding().getId());
    submission.setAssignmentId(assignmentId);
    submission.setSubmissionTime(new Date());
    submission.setSecurityCode(securityCode);
    submission.setResourceId(resourceId);
    submission.setResourceSubdirectory(
        pageContext.getSession().getPersonBinding().getUniqueIdentifier());
    submission.setActive(false); // Must use make-active

    try {
      f.beginTransaction();
      ISubmissionDAO submissionDao = f.getSubmissionDAOInstance();
      IStudentInterfaceQueriesDAO studentInterfaceQueriesDAo =
          f.getStudentInterfaceQueriesDAOInstance();
      submission.setId(submissionDao.createPersistentCopy(submission));
      studentInterfaceQueriesDAo.makeSubmissionActive(
          submission.getPersonId(), submission.getAssignmentId(), submission.getId());
      f.endTransaction();
    } catch (DAOException e) {
      f.abortTransaction();

      try {
        f.beginTransaction();

        IResourceDAO resourceDao = f.getResourceDAOInstance();
        resourceDao.deletePersistentEntity(resourceId);

        f.endTransaction();
      } catch (DAOException e2) {
        throw new ServletException(
            "dao error occured - additional error cleaning stale resource " + resourceId, e);
      }

      throw new ServletException("dao error occured", e);
    }

    // Well, that seemed to be successful(!)
    templateContext.put("person", pageContext.getSession().getPersonBinding());
    templateContext.put("submission", submission);
    templateContext.put("now", new Date());

    // Write out mail.
    StringWriter pw = new StringWriter();
    emailTemplate.merge(templateContext, pw);
    try {
      mailSender.sendMail(
          pageContext.getSession().getPersonBinding().getEmailAddress(),
          "Submission (" + assignment.getName() + ")",
          pw.toString());
      templateContext.put("mailSent", true);
      pageContext.log(
          Level.INFO,
          "student submission mail sent (email: "
              + pageContext.getSession().getPersonBinding().getEmailAddress()
              + ") (code: "
              + securityCode
              + ")");
    } catch (MailException e) {
      templateContext.put("mailSent", false);
      pageContext.log(
          Level.ERROR,
          "student submission mail NOT sent (email: "
              + pageContext.getSession().getPersonBinding().getEmailAddress()
              + ") (code: "
              + securityCode
              + ")");
      pageContext.log(Level.ERROR, e);
    }

    // Display the page
    pageContext.log(
        Level.INFO,
        "student submission successful (student: "
            + pageContext.getSession().getPersonBinding().getUniqueIdentifier()
            + ") (code: "
            + securityCode
            + ") (submission: "
            + submission.getId()
            + ")");
    templateContext.put("greet", pageContext.getSession().getPersonBinding().getChosenName());
    pageContext.renderTemplate(template, templateContext);
  }
  @RvdAuth
  @POST
  // @Path("{name}/archive")
  public Response importProjectArchive(
      @Context HttpServletRequest request, @QueryParam("ticket") String ticket) {
    logger.info("Importing project from raw archive");
    ProjectApplicationsApi applicationsApi = null;
    String projectName = null;

    try {
      if (request.getHeader("Content-Type") != null
          && request.getHeader("Content-Type").startsWith("multipart/form-data")) {
        Gson gson = new Gson();
        ServletFileUpload upload = new ServletFileUpload();
        FileItemIterator iterator = upload.getItemIterator(request);

        JsonArray fileinfos = new JsonArray();

        while (iterator.hasNext()) {
          FileItemStream item = iterator.next();
          JsonObject fileinfo = new JsonObject();
          fileinfo.addProperty("fieldName", item.getFieldName());

          // is this a file part (talking about multipart requests, there might be parts that are
          // not actual files).
          // They will be ignored
          if (item.getName() != null) {
            String effectiveProjectName =
                projectService.importProjectFromArchive(item.openStream(), item.getName());
            // buildService.buildProject(effectiveProjectName);

            // Load project kind
            String projectString =
                FsProjectStorage.loadProjectString(effectiveProjectName, workspaceStorage);
            ProjectState state = marshaler.toModel(projectString, ProjectState.class);
            String projectKind = state.getHeader().getProjectKind();
            projectName = effectiveProjectName;

            // Create application
            applicationsApi =
                new ProjectApplicationsApi(servletContext, workspaceStorage, marshaler);
            applicationsApi.createApplication(ticket, effectiveProjectName, projectKind);

            fileinfo.addProperty("name", item.getName());
            fileinfo.addProperty("projectName", effectiveProjectName);
          }
          if (item.getName() == null) {
            logger.warn("non-file part found in upload");
            fileinfo.addProperty("value", read(item.openStream()));
          }
          fileinfos.add(fileinfo);
        }
        return Response.ok(gson.toJson(fileinfos), MediaType.APPLICATION_JSON).build();
      } else {
        String json_response = "{\"result\":[{\"size\":" + size(request.getInputStream()) + "}]}";
        return Response.ok(json_response, MediaType.APPLICATION_JSON).build();
      }
    } catch (StorageException e) {
      logger.warn(e, e);
      logger.debug(e, e);
      return buildErrorResponse(Status.BAD_REQUEST, RvdResponse.Status.ERROR, e);
    } catch (ApplicationAlreadyExists e) {
      logger.warn(e, e);
      logger.debug(e, e);
      try {
        applicationsApi.rollbackCreateApplication(ticket, projectName);
      } catch (ApplicationsApiSyncException e1) {
        logger.error(e1.getMessage(), e1);
        return buildErrorResponse(Status.INTERNAL_SERVER_ERROR, RvdResponse.Status.ERROR, e);
      }
      return buildErrorResponse(Status.CONFLICT, RvdResponse.Status.ERROR, e);
    } catch (Exception e /* TODO - use a more specific type !!! */) {
      logger.error(e.getMessage(), e);
      return Response.status(Status.INTERNAL_SERVER_ERROR).build();
    }
  }
Example #23
0
  /** Receive Request */
  @Override
  public void doPost(HttpServletRequest req, HttpServletResponse res)
      throws ServletException, IOException {

    JSONObject result = new JSONObject();
    try {
      result.put(Constants.ERROR_CODE, Constants.ACTION_FAILED);
      result.put(
          Constants.ERROR_MSG, reg.getMessage("ACT0002", session.getLanguage(req.getSession())));
    } catch (Exception e) {
    }

    Connection conn = DSManager.getConnection();
    ServletFileUpload upload = new ServletFileUpload();

    try {
      UserInfo user = session.getUserInfo(req.getSession());
      if (user == null) {
        throw new Exception(reg.getMessage("ACT0003"));
      }

      JSONArray data = new JSONArray();

      int l = 0;
      FileItemIterator iterator = upload.getItemIterator(req);
      while (iterator.hasNext()) {
        FileItemStream item = iterator.next();

        if (item.isFormField()) {

        } else {

          conn.setAutoCommit(false);

          UserDAO dao = new UserDAO();

          String today = Utils.getTodayWithTime();

          conn.commit();

          try {
            int user_id = -1,
                firstname = -1,
                lastname = -1,
                username = -1,
                email = -1,
                password = -1;
            int newhire = -1, manager = -1, owner = -1, promote = -1, jobgrade = -1;
            int geographical = -1, city = -1, division = -1, sub_division = -1;

            boolean isHeader = true;

            BufferedReader reader = new BufferedReader(new InputStreamReader(item.openStream()));

            String line = null;
            do {
              line = reader.readLine();
              if (line != null) {
                data.put(line.replaceAll("\"", ""));
                l++;
              }

            } while (line != null);

            reader.close();
          } catch (Exception fff) {
          }

          conn.commit();
        }
      }

      result.put("data", data);
      result.put("len", l);
      result.put(Constants.ERROR_CODE, Constants.ACTION_SUCCESS);
      result.put(
          Constants.ERROR_MSG, reg.getMessage("ACT0001", session.getLanguage(req.getSession())));
    } catch (Exception e) {
      try {
        conn.rollback();
      } catch (Exception ff) {
      }
    } finally {
      try {
        if (conn != null) conn.close();
      } catch (Exception f) {
      }
    }

    res.setContentType("text/plain;charset=UTF-8");
    try {
      res.getWriter().print(result.toString());
    } catch (Exception e) {
    }
  }
  @SuppressWarnings("unchecked")
  public RequestParameterMapMultiPartImpl(
      BridgeContext bridgeContext, ClientDataRequest clientDataRequest) {

    try {

      PortletSession portletSession = clientDataRequest.getPortletSession();
      PortletContext portletContext = portletSession.getPortletContext();

      // Determine the uploaded files directory path according to the JSF 2.2 proposal:
      // https://javaserverfaces-spec-public.dev.java.net/issues/show_bug.cgi?id=690
      String uploadedFilesDir = portletContext.getInitParameter(CONTEXT_PARAM_UPLOADED_FILES_DIR);

      if (uploadedFilesDir == null) {
        uploadedFilesDir = System.getProperty(JAVA_IO_TMPDIR);

        if (logger.isDebugEnabled()) {
          logger.debug(
              "The web.xml context-param name=[{0}] not found, using default system property=[{1}] value=[{2}]",
              new Object[] {CONTEXT_PARAM_UPLOADED_FILES_DIR, JAVA_IO_TMPDIR, uploadedFilesDir});
        }
      } else {

        if (logger.isDebugEnabled()) {
          logger.debug(
              "Using web.xml context-param name=[{0}] value=[{1}]",
              new Object[] {CONTEXT_PARAM_UPLOADED_FILES_DIR, uploadedFilesDir});
        }
      }

      // Using the portlet sessionId, determine a unique folder path and create the path if it does
      // not exist.
      String sessionId = portletSession.getId();
      File uploadedFilesPath = new File(uploadedFilesDir, sessionId);

      if (!uploadedFilesPath.exists()) {

        try {
          uploadedFilesPath.mkdirs();
        } catch (SecurityException e) {
          uploadedFilesDir = System.getProperty(JAVA_IO_TMPDIR);
          logger.error(
              "Security exception message=[{0}] when trying to create unique path=[{1}] so using default system property=[{2}] value=[{3}]",
              new Object[] {
                e.getMessage(), uploadedFilesPath.toString(), JAVA_IO_TMPDIR, uploadedFilesDir
              });
          uploadedFilesPath = new File(uploadedFilesDir, sessionId);
          uploadedFilesPath.mkdirs();
        }
      }

      // Initialize commons-fileupload with the file upload path.
      DiskFileItemFactory diskFileItemFactory = new DiskFileItemFactory();
      diskFileItemFactory.setRepository(uploadedFilesPath);

      // Initialize commons-fileupload so that uploaded temporary files are not automatically
      // deleted.
      diskFileItemFactory.setFileCleaningTracker(null);

      // Initialize the commons-fileupload size threshold to zero, so that all files will be dumped
      // to disk
      // instead of staying in memory.
      diskFileItemFactory.setSizeThreshold(0);

      // Determine the max file upload size threshold in bytes.
      String uploadedFilesMaxSize =
          portletContext.getInitParameter(CONTEXT_PARAM_UPLOADED_FILE_MAX_SIZE);
      int fileMaxSize = DEFAULT_FILE_MAX_SIZE;

      if (uploadedFilesMaxSize == null) {

        if (logger.isDebugEnabled()) {
          logger.debug(
              "The web.xml context-param name=[{0}] not found, using default=[{1}] bytes",
              new Object[] {CONTEXT_PARAM_UPLOADED_FILE_MAX_SIZE, DEFAULT_FILE_MAX_SIZE});
        }
      } else {

        try {
          fileMaxSize = Integer.parseInt(uploadedFilesMaxSize);

          if (logger.isDebugEnabled()) {
            logger.debug(
                "Using web.xml context-param name=[{0}] value=[{1}] bytes",
                new Object[] {CONTEXT_PARAM_UPLOADED_FILE_MAX_SIZE, fileMaxSize});
          }
        } catch (NumberFormatException e) {
          logger.error(
              "Invalid value=[{0}] for web.xml context-param name=[{1}] using default=[{2}] bytes.",
              new Object[] {
                uploadedFilesMaxSize, CONTEXT_PARAM_UPLOADED_FILE_MAX_SIZE, DEFAULT_FILE_MAX_SIZE
              });
        }
      }

      // Parse the request parameters and save all uploaded files in a map.
      PortletFileUpload portletFileUpload = new PortletFileUpload(diskFileItemFactory);
      portletFileUpload.setFileSizeMax(fileMaxSize);
      requestParameterMap = new HashMap<String, String>();
      requestParameterFileMap = new HashMap<String, List<UploadedFile>>();

      // Get the namespace that might be found in request parameter names.
      String namespace = bridgeContext.getPortletContainer().getResponseNamespace();

      // FACES-271: Include name+value pairs found in the ActionRequest.
      PortletContainer portletContainer = bridgeContext.getPortletContainer();
      Set<Map.Entry<String, String[]>> actionRequestParameterSet =
          clientDataRequest.getParameterMap().entrySet();

      for (Map.Entry<String, String[]> mapEntry : actionRequestParameterSet) {

        String parameterName = mapEntry.getKey();
        int pos = parameterName.indexOf(namespace);

        if (pos >= 0) {
          parameterName = parameterName.substring(pos + namespace.length());
        }

        String[] parameterValues = mapEntry.getValue();

        if (parameterValues.length > 0) {
          String fixedRequestParameterValue =
              portletContainer.fixRequestParameterValue(parameterValues[0]);
          requestParameterMap.put(parameterName, fixedRequestParameterValue);
          logger.debug(
              "Found in ActionRequest: {0}=[{1}]", parameterName, fixedRequestParameterValue);
        }
      }

      UploadedFileFactory uploadedFileFactory =
          (UploadedFileFactory) BridgeFactoryFinder.getFactory(UploadedFileFactory.class);

      // Begin parsing the request for file parts:
      try {
        FileItemIterator fileItemIterator = null;

        if (clientDataRequest instanceof ResourceRequest) {
          ResourceRequest resourceRequest = (ResourceRequest) clientDataRequest;
          fileItemIterator =
              portletFileUpload.getItemIterator(new ActionRequestAdapter(resourceRequest));
        } else {
          ActionRequest actionRequest = (ActionRequest) clientDataRequest;
          fileItemIterator = portletFileUpload.getItemIterator(actionRequest);
        }

        boolean optimizeNamespace =
            BooleanHelper.toBoolean(
                bridgeContext.getInitParameter(
                    BridgeConfigConstants.PARAM_OPTIMIZE_PORTLET_NAMESPACE1),
                true);

        if (fileItemIterator != null) {

          int totalFiles = 0;

          // For each field found in the request:
          while (fileItemIterator.hasNext()) {

            try {
              totalFiles++;

              // Get the stream of field data from the request.
              FileItemStream fieldStream = (FileItemStream) fileItemIterator.next();

              // Get field name from the field stream.
              String fieldName = fieldStream.getFieldName();

              // If namespace optimization is enabled and the namespace is present in the field
              // name,
              // then remove the portlet namespace from the field name.
              if (optimizeNamespace) {
                int pos = fieldName.indexOf(namespace);

                if (pos >= 0) {
                  fieldName = fieldName.substring(pos + namespace.length());
                }
              }

              // Get the content-type, and file-name from the field stream.
              String contentType = fieldStream.getContentType();
              boolean formField = fieldStream.isFormField();

              String fileName = null;

              try {
                fileName = fieldStream.getName();
              } catch (InvalidFileNameException e) {
                fileName = e.getName();
              }

              // Copy the stream of file data to a temporary file. NOTE: This is necessary even if
              // the
              // current field is a simple form-field because the call below to
              // diskFileItem.getString()
              // will fail otherwise.
              DiskFileItem diskFileItem =
                  (DiskFileItem)
                      diskFileItemFactory.createItem(fieldName, contentType, formField, fileName);
              Streams.copy(fieldStream.openStream(), diskFileItem.getOutputStream(), true);

              // If the current field is a simple form-field, then save the form field value in the
              // map.
              if (diskFileItem.isFormField()) {
                String requestParameterValue =
                    diskFileItem.getString(clientDataRequest.getCharacterEncoding());
                String fixedRequestParameterValue =
                    portletContainer.fixRequestParameterValue(requestParameterValue);
                requestParameterMap.put(fieldName, fixedRequestParameterValue);
                logger.debug("{0}=[{1}]", fieldName, fixedRequestParameterValue);
              } else {

                File tempFile = diskFileItem.getStoreLocation();

                // If the copy was successful, then
                if (tempFile.exists()) {

                  // Copy the commons-fileupload temporary file to a file in the same temporary
                  // location, but with the filename provided by the user in the upload. This has
                  // two
                  // benefits: 1) The temporary file will have a nice meaningful name. 2) By copying
                  // the file, the developer can have access to a semi-permanent file, because the
                  // commmons-fileupload DiskFileItem.finalize() method automatically deletes the
                  // temporary one.
                  String tempFileName = tempFile.getName();
                  String tempFileAbsolutePath = tempFile.getAbsolutePath();

                  String copiedFileName = stripIllegalCharacters(fileName);

                  String copiedFileAbsolutePath =
                      tempFileAbsolutePath.replace(tempFileName, copiedFileName);
                  File copiedFile = new File(copiedFileAbsolutePath);
                  FileUtils.copyFile(tempFile, copiedFile);

                  // If present, build up a map of headers.
                  Map<String, List<String>> headersMap = new HashMap<String, List<String>>();
                  FileItemHeaders fileItemHeaders = fieldStream.getHeaders();

                  if (fileItemHeaders != null) {
                    Iterator<String> headerNameItr = fileItemHeaders.getHeaderNames();

                    if (headerNameItr != null) {

                      while (headerNameItr.hasNext()) {
                        String headerName = headerNameItr.next();
                        Iterator<String> headerValuesItr = fileItemHeaders.getHeaders(headerName);
                        List<String> headerValues = new ArrayList<String>();

                        if (headerValuesItr != null) {

                          while (headerValuesItr.hasNext()) {
                            String headerValue = headerValuesItr.next();
                            headerValues.add(headerValue);
                          }
                        }

                        headersMap.put(headerName, headerValues);
                      }
                    }
                  }

                  // Put a valid UploadedFile instance into the map that contains all of the
                  // uploaded file's attributes, along with a successful status.
                  Map<String, Object> attributeMap = new HashMap<String, Object>();
                  String id = Long.toString(((long) hashCode()) + System.currentTimeMillis());
                  String message = null;
                  UploadedFile uploadedFile =
                      uploadedFileFactory.getUploadedFile(
                          copiedFileAbsolutePath,
                          attributeMap,
                          diskFileItem.getCharSet(),
                          diskFileItem.getContentType(),
                          headersMap,
                          id,
                          message,
                          fileName,
                          diskFileItem.getSize(),
                          UploadedFile.Status.FILE_SAVED);

                  requestParameterMap.put(fieldName, copiedFileAbsolutePath);
                  addUploadedFile(fieldName, uploadedFile);
                  logger.debug(
                      "Received uploaded file fieldName=[{0}] fileName=[{1}]", fieldName, fileName);
                }
              }
            } catch (Exception e) {
              logger.error(e);

              UploadedFile uploadedFile = uploadedFileFactory.getUploadedFile(e);
              String fieldName = Integer.toString(totalFiles);
              addUploadedFile(fieldName, uploadedFile);
            }
          }
        }
      }

      // If there was an error in parsing the request for file parts, then put a bogus UploadedFile
      // instance in
      // the map so that the developer can have some idea that something went wrong.
      catch (Exception e) {
        logger.error(e);

        UploadedFile uploadedFile = uploadedFileFactory.getUploadedFile(e);
        addUploadedFile("unknown", uploadedFile);
      }

      clientDataRequest.setAttribute(PARAM_UPLOADED_FILES, requestParameterFileMap);

      // If not found in the request, Section 6.9 of the Bridge spec requires that the value of the
      // ResponseStateManager.RENDER_KIT_ID_PARAM request parameter be set to the value of the
      // "javax.portlet.faces.<portletName>.defaultRenderKitId" PortletContext attribute.
      String renderKitIdParam = requestParameterMap.get(ResponseStateManager.RENDER_KIT_ID_PARAM);

      if (renderKitIdParam == null) {
        renderKitIdParam = bridgeContext.getDefaultRenderKitId();

        if (renderKitIdParam != null) {
          requestParameterMap.put(ResponseStateManager.RENDER_KIT_ID_PARAM, renderKitIdParam);
        }
      }
    } catch (Exception e) {
      logger.error(e.getMessage(), e);
    }
  }
Example #25
0
  public void doGet(HttpServletRequest req, HttpServletResponse resp)
      throws IOException, ServletException {
    boolean isMultipart = FileUpload.isMultipartContent(req);
    Hashtable dv = new Hashtable();
    String user = null;
    String password = null;
    String sql = null;
    String dfo = null;
    String enc = null;
    if (isMultipart) {

      ServletFileUpload upload = new ServletFileUpload();

      upload.setSizeMax(mU);
      try {
        FileItemIterator iter = upload.getItemIterator(req);
        // List<FileItem> items = upload.parseRequest(req);

        while (iter.hasNext()) {
          FileItemStream item = iter.next();
          // for (int ct = 0;ct < items.size();ct++){

          //         FileItem item = (FileItem)items.get(ct);

          String name = item.getName();
          // (name + " jiql UREEAD 1aay " + item.isFormField() + ":" + name.equals("directValues"));

          InputStream stream = item.openStream();
          // InputStream stream = item.getInputStream();

          //// (name + " jiql UREEAD 1 " + stream.available());
          // byte[] b = StreamUtil.readBytes(stream);

          if (name.equals("directValues")) {
            // (stream.available() + " jiql UREEAD " );

            // ByteArrayInputStream bout = new ByteArrayInputStream(b);
            ObjectInputStream dout = new ObjectInputStream(stream);

            // ObjectInputStream dout = new ObjectInputStream(bout);
            dv = (Hashtable) dout.readObject();
          }
        }

      } catch (Exception e) {
        tools.util.LogMgr.err("JS.readDV " + e.toString());
        e.printStackTrace();
      }
      // ("$$$ DV " + dv);
      Hashtable pars = (Hashtable) dv.get("parameters");
      if (pars != null) {
        Enumeration en = pars.keys();
        while (en.hasMoreElements()) {
          String n = en.nextElement().toString();
          // ("PARSMS " + n);
          if (n.equals("query")) sql = pars.get(n).toString();
          else if (n.equals("password")) password = pars.get(n).toString();
          else if (n.equals("user")) user = pars.get(n).toString();
          else if (n.equals("date.format")) dfo = pars.get(n).toString();
          else if (n.equals("encoding")) enc = pars.get(n).toString();
        }
      }
    }

    if (user == null) user = req.getParameter("user");
    if (password == null) password = req.getParameter("password");
    if (!StringUtil.isRealString(user) || !StringUtil.isRealString(password)) {
      resp.sendError(403, "Invalid User or Password");
      return;
    }

    if (!StringUtil.isRealString(theUser) || !StringUtil.isRealString(thePassword)) {
      resp.sendError(403, "Invalid User OR Password");
      return;
    }

    Connection Conn = null;
    Hashtable h = new Hashtable();
    h.put("remote", "true");
    try {
      //	NameValuePairs p = new NameValuePairs(ps);
      if (!user.equals(theUser) || !password.equals(thePassword)) {
        resp.sendError(403, "Invalid User OR Invalid Password");
        return;
      }
      // throw new ServletException("Invalid User OR Password");
      if (sql == null) sql = req.getParameter("query");
      // ( "THE SQL " + sql);
      NameValuePairs nvp = new NameValuePairs();
      if (dfo == null) dfo = req.getParameter("date.format");
      if (dfo != null) nvp.put("date.format", dfo);

      if (enc == null) enc = req.getParameter("encoding");
      if (enc != null) nvp.put("encoding", enc);

      Conn = get(nvp);

      org.jiql.jdbc.Statement Stmt = (org.jiql.jdbc.Statement) Conn.createStatement();
      Stmt.setDirectValues(dv);

      Stmt.execute(sql);
      org.jiql.jdbc.ResultSet res = (org.jiql.jdbc.ResultSet) Stmt.getResultSet();

      if (res != null) {

        if (res.getResults() != null) h.put("results", res.getResults());
        if (res.getSQLParser() != null) h.put("sqlparser", res.getSQLParser());
      } else h.put("sqlparser", Stmt.getSQLParser());

      // h.put("remote","true");
      resp.setContentType("binary/object");
      // if (enc != null)
      //	resp.setCharacterEncoding(enc);
      OutputStream fos = resp.getOutputStream();
      ObjectOutputStream oos = new ObjectOutputStream(fos);
      oos.writeObject(h);
      // resp.getWriter(). ("result" + h);

    } catch (Exception ex) {
      org.jiql.util.JGUtil.olog(ex);
      ex.printStackTrace();
      tools.util.LogMgr.err("JIQLServlet " + ex.toString());
      JGException je = null;
      if (ex instanceof JGException) je = (JGException) ex;
      else je = new JGException(ex.toString());

      h.put("error", je);

      resp.setContentType("binary/object");
      OutputStream fos = resp.getOutputStream();
      ObjectOutputStream oos = new ObjectOutputStream(fos);
      oos.writeObject(h);

      // throw new ServletException(ex.toString());
    } finally {
      if (Conn != null)
        try {

          Conn.close();
        } catch (Exception ex) {
          ex.printStackTrace();
        }
    }
  }
  public void doPost(HttpServletRequest req, HttpServletResponse res)
      throws ServletException, IOException {

    try {
      String xml = "";
      // Initializing the servlet response
      res.setContentType("text/xml");
      //  res.setHeader("Expires", "0");
      //  res.setHeader("Cache-Control", "no-cache");
      // res.setHeader("Pragma", "public");
      String fileName = "dump.xml";
      res.setHeader("Content-Disposition", "attachment; filename=\"" + fileName + "\"");
      res.setCharacterEncoding("utf-8");
      //    res.setHeader("Transfer-Encoding", "Chunked");
      // res.setBufferSize(baos.size());
      // res.flushBuffer();

      ServletFileUpload upload = new ServletFileUpload();

      ServletOutputStream out = res.getOutputStream();
      FileItemIterator iterator = upload.getItemIterator(req);
      while (iterator.hasNext()) {
        FileItemStream item = iterator.next();
        InputStream stream = item.openStream();

        if (item.isFormField()) {
          log.warning("Got a form field: " + item.getFieldName());
        } else {
          log.warning(
              "Got an uploaded file: " + item.getFieldName() + ", name = " + item.getName());

          // You now have the filename (item.getName() and the
          // contents (which you can read from stream).  Here we just
          // print them back out to the servlet output stream, but you
          // will probably want to do something more interesting (for
          // example, wrap them in a Blob and commit them to the
          // datastore).

          int len;
          byte[] buffer = new byte[8192];
          while ((len = stream.read(buffer, 0, buffer.length)) != -1) {
            // log.info("writing data...");
            // out.write(buffer, 0, len);
            // log.info("buffer: " + new String(buffer));
            xml = xml + new String(buffer);
          }
        }
      }

      log.info("end of while");

      dummy(xml);

      // log.info("writing data...");
      // out.write(xml.getBytes());
      out.flush();
      out.close();
      log.info("stream closed");
    } catch (Exception ex) {
      throw new ServletException(ex);
    }
  }