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);
}
}
}
@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());
}
}
