protected void handlePlaintext(
      ContentProfileProvider modelProvider,
      SubmissionTemplate template,
      Submission.Builder submissionBuilder,
      Attachment attachment,
      String actingAsId)
      throws PieceworkException {
    String contentType = MediaType.TEXT_PLAIN;
    if (LOG.isDebugEnabled())
      LOG.debug(
          "Processing multipart with content type "
              + contentType
              + " and content id "
              + attachment.getContentId());

    String name = sanitizer.sanitize(attachment.getDataHandler().getName());
    String value = sanitizer.sanitize(attachment.getObject(String.class));

    if (!submissionStorageService.store(
        modelProvider, template, submissionBuilder, name, value, actingAsId)) {
      LOG.warn(
          "Submission included field ("
              + name
              + ") that is not acceptable, and no attachments are allowed for this template");
    }
  }
  protected void handleAllContentTypes(
      ContentProfileProvider modelProvider,
      SubmissionTemplate template,
      Submission.Builder submissionBuilder,
      Attachment attachment,
      String actingAsId)
      throws PieceworkException {
    ContentDisposition contentDisposition = attachment.getContentDisposition();
    MediaType mediaType = attachment.getContentType();

    if (contentDisposition != null) {
      String contentType = mediaType.toString();
      String name = sanitizer.sanitize(contentDisposition.getParameter("name"));
      String filename = sanitizer.sanitize(contentDisposition.getParameter("filename"));
      if (StringUtils.isNotEmpty(filename)) {
        if (LOG.isDebugEnabled())
          LOG.debug(
              "Processing multipart with content type "
                  + contentType
                  + " content id "
                  + attachment.getContentId()
                  + " and filename "
                  + filename);
        try {
          if (!submissionStorageService.store(
              modelProvider,
              template,
              submissionBuilder,
              name,
              filename,
              actingAsId,
              attachment.getDataHandler().getInputStream(),
              contentType)) {
            LOG.warn(
                "Submission included field ("
                    + name
                    + ") that is not acceptable, and no attachments are allowed for this template");
          }
        } catch (IOException e) {
          LOG.warn(
              "Unable to store file with content type "
                  + contentType
                  + " and filename "
                  + filename);
        }
      } else if (mediaType.equals(MediaType.TEXT_PLAIN_TYPE)) {
        handlePlaintext(modelProvider, template, submissionBuilder, attachment, actingAsId);
      }
    }
  }
Exemplo n.º 3
0
  @POST
  @Path("/")
  public Response addDatastreams(
      @PathParam("pid") final String pid, final List<Attachment> attachmentList)
      throws RepositoryException, IOException {

    final Session session = repo.login();
    try {
      Long oldObjectSize = getObjectSize(session.getNode(getObjectJcrNodePath(pid)));

      for (final Attachment a : attachmentList) {
        final String dsid = a.getContentDisposition().getParameter("name");
        final String dsPath = getDatastreamJcrNodePath(pid, dsid);
        createDatastreamNode(
            session,
            dsPath,
            a.getDataHandler().getContentType(),
            a.getDataHandler().getInputStream());
      }
      session.save();

      /*
       * we save before updating the repo size because the act of
       * persisting session state creates new system-curated nodes and
       * properties which contribute to the footprint of this resource
       */
      updateRepositorySize(
          getObjectSize(session.getNode(getObjectJcrNodePath(pid))) - oldObjectSize, session);
      // now we save again to persist the repo size
      session.save();
    } finally {
      session.logout();
    }

    return created(uriInfo.getAbsolutePath()).build();
  }
  protected RestVariable createBinaryExecutionVariable(
      Execution execution,
      int responseVariableType,
      UriInfo uriInfo,
      boolean isNew,
      MultipartBody multipartBody) {

    boolean debugEnabled = log.isDebugEnabled();
    Response.ResponseBuilder responseBuilder = Response.ok();

    List<org.apache.cxf.jaxrs.ext.multipart.Attachment> attachments =
        multipartBody.getAllAttachments();

    int attachmentSize = attachments.size();

    if (attachmentSize <= 0) {
      throw new ActivitiIllegalArgumentException("No Attachments found with the request body");
    }
    AttachmentDataHolder attachmentDataHolder = new AttachmentDataHolder();

    for (int i = 0; i < attachmentSize; i++) {
      org.apache.cxf.jaxrs.ext.multipart.Attachment attachment = attachments.get(i);

      String contentDispositionHeaderValue = attachment.getHeader("Content-Disposition");
      String contentType = attachment.getHeader("Content-Type");

      if (debugEnabled) {
        log.debug("Going to iterate:" + i);
        log.debug("contentDisposition:" + contentDispositionHeaderValue);
      }

      if (contentDispositionHeaderValue != null) {
        contentDispositionHeaderValue = contentDispositionHeaderValue.trim();

        Map<String, String> contentDispositionHeaderValueMap =
            Utils.processContentDispositionHeader(contentDispositionHeaderValue);
        String dispositionName = contentDispositionHeaderValueMap.get("name");
        DataHandler dataHandler = attachment.getDataHandler();

        OutputStream outputStream = null;

        if ("name".equals(dispositionName)) {
          try {
            outputStream = Utils.getAttachmentStream(dataHandler.getInputStream());
          } catch (IOException e) {
            throw new ActivitiIllegalArgumentException("Attachment Name Reading error occured", e);
          }

          if (outputStream != null) {
            String fileName = outputStream.toString();
            attachmentDataHolder.setName(fileName);
          }

        } else if ("type".equals(dispositionName)) {
          try {
            outputStream = Utils.getAttachmentStream(dataHandler.getInputStream());
          } catch (IOException e) {
            throw new ActivitiIllegalArgumentException("Attachment Type Reading error occured", e);
          }

          if (outputStream != null) {
            String typeName = outputStream.toString();
            attachmentDataHolder.setType(typeName);
          }

        } else if ("scope".equals(dispositionName)) {
          try {
            outputStream = Utils.getAttachmentStream(dataHandler.getInputStream());
          } catch (IOException e) {
            throw new ActivitiIllegalArgumentException(
                "Attachment Description Reading error occured", e);
          }

          if (outputStream != null) {
            String description = outputStream.toString();
            attachmentDataHolder.setScope(description);
          }
        }

        if (contentType != null) {
          if ("file".equals(dispositionName)) {

            InputStream inputStream = null;
            try {
              inputStream = dataHandler.getInputStream();
            } catch (IOException e) {
              throw new ActivitiIllegalArgumentException(
                  "Error Occured During processing empty body.", e);
            }

            if (inputStream != null) {
              attachmentDataHolder.setContentType(contentType);
              byte[] attachmentArray = new byte[0];
              try {
                attachmentArray = IOUtils.toByteArray(inputStream);
              } catch (IOException e) {
                throw new ActivitiIllegalArgumentException("Processing Attachment Body Failed.", e);
              }
              attachmentDataHolder.setAttachmentArray(attachmentArray);
            }
          }
        }
      }
    }

    attachmentDataHolder.printDebug();

    if (attachmentDataHolder.getName() == null) {
      throw new ActivitiIllegalArgumentException("Attachment name is required.");
    }

    if (attachmentDataHolder.getAttachmentArray() == null) {
      throw new ActivitiIllegalArgumentException(
          "Empty attachment body was found in request body after " + "decoding the request" + ".");
    }
    String variableScope = attachmentDataHolder.getScope();
    String variableName = attachmentDataHolder.getName();
    String variableType = attachmentDataHolder.getType();

    if (log.isDebugEnabled()) {
      log.debug(
          "variableScope:"
              + variableScope
              + " variableName:"
              + variableName
              + " variableType:"
              + variableType);
    }

    try {

      // Validate input and set defaults
      if (variableName == null) {
        throw new ActivitiIllegalArgumentException("No variable name was found in request body.");
      }

      if (variableType != null) {
        if (!RestResponseFactory.BYTE_ARRAY_VARIABLE_TYPE.equals(variableType)
            && !RestResponseFactory.SERIALIZABLE_VARIABLE_TYPE.equals(variableType)) {
          throw new ActivitiIllegalArgumentException(
              "Only 'binary' and 'serializable' are supported as variable type.");
        }
      } else {
        variableType = RestResponseFactory.BYTE_ARRAY_VARIABLE_TYPE;
      }

      RestVariable.RestVariableScope scope = RestVariable.RestVariableScope.LOCAL;
      if (variableScope != null) {
        scope = RestVariable.getScopeFromString(variableScope);
      }

      if (variableType.equals(RestResponseFactory.BYTE_ARRAY_VARIABLE_TYPE)) {
        // Use raw bytes as variable value
        setVariable(
            execution, variableName, attachmentDataHolder.getAttachmentArray(), scope, isNew);

      } else {
        // Try deserializing the object
        InputStream inputStream =
            new ByteArrayInputStream(attachmentDataHolder.getAttachmentArray());
        ObjectInputStream stream = new ObjectInputStream(inputStream);
        Object value = stream.readObject();
        setVariable(execution, variableName, value, scope, isNew);
        stream.close();
      }

      if (responseVariableType == RestResponseFactory.VARIABLE_PROCESS) {
        return new RestResponseFactory()
            .createBinaryRestVariable(
                variableName,
                scope,
                variableType,
                null,
                null,
                execution.getId(),
                uriInfo.getBaseUri().toString());
      } else {
        return new RestResponseFactory()
            .createBinaryRestVariable(
                variableName,
                scope,
                variableType,
                null,
                execution.getId(),
                null,
                uriInfo.getBaseUri().toString());
      }

    } catch (IOException ioe) {
      throw new ActivitiIllegalArgumentException("Could not process multipart content", ioe);
    } catch (ClassNotFoundException ioe) {
      throw new BPMNContentNotSupportedException(
          "The provided body contains a serialized object for which the class is nog found: "
              + ioe.getMessage());
    }
  }