public static PopupForm fromRequest(String uuid, HttpServletRequest request) {
String descriptor = request.getParameter("descriptor");
boolean isOpenCampaign = "open-campaign".equals(request.getParameter("open-campaign"));
long startTime =
"".equals(request.getParameter("start_time"))
? 0
: parseTime(request.getParameter("start_time_selected_datetime"));
long endTime =
"".equals(request.getParameter("end_time"))
? 0
: parseTime(request.getParameter("end_time_selected_datetime"));
List<String> assignees = new ArrayList<String>();
if (request.getParameter("distribution") != null) {
for (String user : request.getParameter("distribution").split("[\r\n]+")) {
if (!user.isEmpty()) {
assignees.add(user);
}
}
}
Optional<DiskFileItem> templateItem = Optional.empty();
DiskFileItem dfi = (DiskFileItem) request.getAttribute("template");
if (dfi != null && dfi.getSize() > 0) {
templateItem = Optional.of(dfi);
}
return new PopupForm(
uuid, descriptor, startTime, endTime, isOpenCampaign, assignees, templateItem);
}
/**
* Parse the tmp file for tag data and create associated song
*
* @param dfi
* @return song created from tag data
*/
public static Song parseFileForSong(DiskFileItem dfi) { // TODO Think about where to move this.
File audioFile = new File(dfi.getStoreLocation().toString().replace(".tmp", ".mp3"));
// "."+dfi.getContentType().substring(dfi.getContentType().indexOf("/")+1)));
if (!dfi.getStoreLocation().renameTo(audioFile)) {
log.error(
"rename failed - store location:" + dfi.getStoreLocation() + ", audio file:" + audioFile);
}
AudioFile f = null;
try {
f = AudioFileIO.read(audioFile);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
Tag tag = f.getTag();
if (tag == null) {
tag = f.getTagOrCreateAndSetDefault();
}
Song song = new Song();
try {
song.setArtist(tag.getFirst(FieldKey.ARTIST));
song.setAlbum(tag.getFirst(FieldKey.ALBUM));
song.setTitle(tag.getFirst(FieldKey.TITLE));
song.setYear(tag.getFirst(FieldKey.YEAR));
song.setTrack(tag.getFirst(FieldKey.TRACK));
song.setFilename(dfi.getName());
} catch (KeyNotFoundException knfe) {
log.error("song key not found", knfe);
}
return song;
}
/*
* (non-Javadoc)
*
* @see org.apache.struts2.dispatcher.multipart.MultiPartRequest#getFilesystemName(java.lang.String)
*/
@Override
public String[] getFilesystemName(String fieldName) {
List<FileItem> items = files.get(fieldName);
if (items == null) {
return null;
}
List<String> fileNames = new ArrayList<String>(items.size());
for (int i = 0; i < items.size(); i++) {
DiskFileItem fileItem = (DiskFileItem) items.get(i);
fileNames.add(fileItem.getStoreLocation().getName());
}
return (String[]) fileNames.toArray(new String[fileNames.size()]);
}
/*
* (non-Javadoc)
*
* @see org.apache.struts2.dispatcher.multipart.MultiPartRequest#getFile(java.lang.String)
*/
@Override
public File[] getFile(String fieldName) {
List<FileItem> items = files.get(fieldName);
if (items == null) {
return null;
}
List<File> fileList = new ArrayList<File>(items.size());
for (int i = 0; i < items.size(); i++) {
DiskFileItem fileItem = (DiskFileItem) items.get(i);
fileList.add(fileItem.getStoreLocation());
}
return (File[]) fileList.toArray(new File[fileList.size()]);
}
public void fileUpload(
CommandArgument argument, HttpServletRequest request, HttpServletResponse response) {
ServletFileUpload upload =
new ServletFileUpload(
new LiferayFileItemFactory(UploadServletRequestImpl.DEFAULT_TEMP_DIR));
List<FileItem> items = null;
try {
items = upload.parseRequest(request);
} catch (FileUploadException fue) {
throw new FCKException(fue);
}
Map<String, Object> fields = new HashMap<String, Object>();
for (FileItem item : items) {
if (item.isFormField()) {
fields.put(item.getFieldName(), item.getString());
} else {
fields.put(item.getFieldName(), item);
}
}
DiskFileItem fileItem = (DiskFileItem) fields.get("NewFile");
String fileName = StringUtil.replace(fileItem.getName(), "\\", "/");
String[] fileNameArray = StringUtil.split(fileName, "/");
fileName = fileNameArray[fileNameArray.length - 1];
String extension = _getExtension(fileName);
String returnValue = null;
try {
returnValue = fileUpload(argument, fileName, fileItem.getStoreLocation(), extension);
} catch (FCKException fcke) {
Throwable cause = fcke.getCause();
returnValue = "203";
if (cause != null) {
String causeString = GetterUtil.getString(cause.toString());
if ((causeString.indexOf("NoSuchFolderException") != -1)
|| (causeString.indexOf("NoSuchGroupException") != -1)) {
returnValue = "204";
} else if (causeString.indexOf("ImageNameException") != -1) {
returnValue = "205";
} else if (causeString.indexOf("FileNameException") != -1) {
returnValue = "206";
} else if (causeString.indexOf("PrincipalException") != -1) {
returnValue = "207";
} else {
throw fcke;
}
}
_writeUploadResponse(returnValue, response);
}
_writeUploadResponse(returnValue, response);
}
@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);
}
}
