@Override
protected void doProcessCommand(PortletRequest portletRequest, PortletResponse portletResponse)
throws Exception {
try {
copyArticle(portletRequest);
} catch (Exception e) {
if (e instanceof NoSuchArticleException || e instanceof PrincipalException) {
SessionErrors.add(portletRequest, e.getClass());
PortletSession portletSession = portletRequest.getPortletSession();
PortletContext portletContext = portletSession.getPortletContext();
PortletRequestDispatcher portletRequestDispatcher =
portletContext.getRequestDispatcher("/html/portlet/journal/error.jsp");
portletRequestDispatcher.include(portletRequest, portletResponse);
} else if (e instanceof DuplicateArticleIdException || e instanceof ArticleIdException) {
SessionErrors.add(portletRequest, e.getClass());
} else {
throw e;
}
}
}
public PortletContext getPortletContext() {
try {
return session.getPortletContext();
} catch (IllegalStateException e) {
throw new SessionExpiredException(e);
}
}
public void serveResource(ResourceRequest resourceRequest, ResourceResponse resourceResponse) {
try {
String portletId = ParamUtil.getString(resourceRequest, "portletId");
LOGGER.debug("portlet id--" + portletId);
SimpleDateFormat timeStampFormat = new SimpleDateFormat(TIMESTAMP_FORMAT_FOR_EXCEL);
PortletSession session = resourceRequest.getPortletSession();
String timeStamp = timeStampFormat.format(Calendar.getInstance().getTime());
String fileName = "Location_Tracker" + timeStamp + ".xls";
List<LocationDetailsVO> locationDetailList =
LocationTrackerReportsUtil.getLocationDetailsVoList(resourceRequest);
JRBeanCollectionDataSource reportList = new JRBeanCollectionDataSource(locationDetailList);
JasperReport report =
JasperCompileManager.compileReport(
session.getPortletContext().getRealPath("/reports/location_tracker_report.jrxml"));
JasperPrint print =
JasperFillManager.fillReport(report, new HashMap<String, Object>(), reportList);
OutputStream os = resourceResponse.getPortletOutputStream();
JRXlsExporter exporterXLS = new JRXlsExporter();
exporterXLS.setParameter(JRXlsExporterParameter.JASPER_PRINT, print);
exporterXLS.setParameter(JRXlsExporterParameter.OUTPUT_STREAM, os);
exporterXLS.setParameter(JRXlsExporterParameter.IS_ONE_PAGE_PER_SHEET, Boolean.FALSE);
exporterXLS.setParameter(JRXlsExporterParameter.IS_DETECT_CELL_TYPE, Boolean.TRUE);
exporterXLS.setParameter(JRXlsExporterParameter.IS_WHITE_PAGE_BACKGROUND, Boolean.FALSE);
exporterXLS.setParameter(
JRXlsExporterParameter.IS_REMOVE_EMPTY_SPACE_BETWEEN_ROWS, Boolean.TRUE);
exporterXLS.exportReport();
resourceResponse.setContentType("application/x-excel");
resourceResponse.setProperty("Content-Disposition", "attachment; filename=" + fileName);
} catch (JRException jre) {
LOGGER.error("Error in exporting the resluts:" + jre.getMessage(), jre);
} catch (Exception e) {
LOGGER.error("Error in exporting the resluts:" + e.getMessage(), e);
}
}
@Override
public void serveResource(ResourceRequest resourceRequest, ResourceResponse resourceResponse)
throws IOException, PortletException {
String resourceID = GetterUtil.getString(resourceRequest.getResourceID());
HttpServletRequest request = PortalUtil.getHttpServletRequest(resourceRequest);
HttpServletResponse response = PortalUtil.getHttpServletResponse(resourceResponse);
if (resourceID.equals("compareVersions")) {
ThemeDisplay themeDisplay =
(ThemeDisplay) resourceRequest.getAttribute(WebKeys.THEME_DISPLAY);
long groupId = ParamUtil.getLong(resourceRequest, "groupId");
String articleId = ParamUtil.getString(resourceRequest, "articleId");
double sourceVersion = ParamUtil.getDouble(resourceRequest, "filterSourceVersion");
double targetVersion = ParamUtil.getDouble(resourceRequest, "filterTargetVersion");
String languageId = ParamUtil.getString(resourceRequest, "languageId");
String diffHtmlResults = null;
try {
diffHtmlResults =
JournalUtil.diffHtml(
groupId,
articleId,
sourceVersion,
targetVersion,
languageId,
new PortletRequestModel(resourceRequest, resourceResponse),
themeDisplay);
} catch (CompareVersionsException cve) {
resourceRequest.setAttribute(WebKeys.DIFF_VERSION, cve.getVersion());
} catch (Exception e) {
try {
PortalUtil.sendError(e, request, response);
} catch (ServletException se) {
}
}
resourceRequest.setAttribute(WebKeys.DIFF_HTML_RESULTS, diffHtmlResults);
PortletSession portletSession = resourceRequest.getPortletSession();
PortletContext portletContext = portletSession.getPortletContext();
PortletRequestDispatcher portletRequestDispatcher =
portletContext.getRequestDispatcher(
"/html/taglib/ui/diff_version_comparator/diff_html.jsp");
portletRequestDispatcher.include(resourceRequest, resourceResponse);
} else if (resourceID.equals("rss")) {
try {
byte[] xml = JournalRSSUtil.getRSS(resourceRequest, resourceResponse);
ServletResponseUtil.sendFile(request, response, null, xml, ContentTypes.TEXT_XML_UTF8);
} catch (Exception e) {
try {
PortalUtil.sendError(e, request, response);
} catch (ServletException se) {
}
}
} else {
super.serveResource(resourceRequest, resourceResponse);
}
}
/*
* (non-Javadoc)
*
* @see javax.servlet.http.HttpSession#getServletContext()
*/
public ServletContext getServletContext() {
return new PortletServletContext(portletSession.getPortletContext());
}
@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);
}
}