mirror of
https://github.com/Alfresco/alfresco-community-repo.git
synced 2025-08-07 17:49:17 +00:00
4fef0c0ef4
125788 rmunteanu: Merged 5.1.N (5.1.2) to 5.2.N (5.2.1)
125606 rmunteanu: Merged 5.1.1 (5.1.1) to 5.1.N (5.1.2)
125515 slanglois: MNT-16155 Update source headers - add new Copyrights for Java and JSP source files + automatic check in the build
git-svn-id: https://svn.alfresco.com/repos/alfresco-enterprise/alfresco/HEAD/root@127810 c4b6b30b-aa2e-2d43-bbcb-ca4b014f7261
389 lines
14 KiB
Java
389 lines
14 KiB
Java
/*
|
|
* #%L
|
|
* Alfresco Repository WAR Community
|
|
* %%
|
|
* Copyright (C) 2005 - 2016 Alfresco Software Limited
|
|
* %%
|
|
* This file is part of the Alfresco software.
|
|
* If the software was purchased under a paid Alfresco license, the terms of
|
|
* the paid license agreement will prevail. Otherwise, the software is
|
|
* provided under the following open source license terms:
|
|
*
|
|
* Alfresco is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* Alfresco is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
|
|
* #L%
|
|
*/
|
|
package org.alfresco.web.app.servlet;
|
|
|
|
import java.io.IOException;
|
|
import java.io.UnsupportedEncodingException;
|
|
import java.net.SocketException;
|
|
import java.util.Enumeration;
|
|
import java.util.HashMap;
|
|
import java.util.Map;
|
|
import java.util.StringTokenizer;
|
|
|
|
import javax.faces.context.FacesContext;
|
|
import javax.servlet.ServletException;
|
|
import javax.servlet.http.HttpServletRequest;
|
|
import javax.servlet.http.HttpServletResponse;
|
|
import javax.transaction.UserTransaction;
|
|
|
|
import org.alfresco.error.AlfrescoRuntimeException;
|
|
import org.alfresco.model.ContentModel;
|
|
import org.alfresco.repo.security.permissions.AccessDeniedException;
|
|
import org.alfresco.repo.web.scripts.FileTypeImageUtils;
|
|
import org.alfresco.service.ServiceRegistry;
|
|
import org.alfresco.service.cmr.repository.FileTypeImageSize;
|
|
import org.alfresco.service.cmr.repository.NodeRef;
|
|
import org.alfresco.service.cmr.repository.NodeService;
|
|
import org.alfresco.service.cmr.repository.StoreRef;
|
|
import org.alfresco.service.cmr.repository.TemplateException;
|
|
import org.alfresco.service.cmr.repository.TemplateImageResolver;
|
|
import org.alfresco.service.cmr.repository.TemplateService;
|
|
import org.alfresco.service.cmr.security.AccessStatus;
|
|
import org.alfresco.service.cmr.security.PermissionService;
|
|
import org.apache.commons.logging.Log;
|
|
|
|
/**
|
|
* Base class for the template content servlets. Provides common
|
|
* processing for the request.
|
|
*
|
|
* @see org.alfresco.web.app.servlet.TemplateContentServlet
|
|
* @see org.alfresco.web.app.servlet.GuestTemplateContentServlet
|
|
*
|
|
* @author Kevin Roast
|
|
* @author gavinc
|
|
*/
|
|
@SuppressWarnings("serial")
|
|
public abstract class BaseTemplateContentServlet extends BaseServlet
|
|
{
|
|
private static final String MIMETYPE_HTML = "text/html;charset=utf-8";
|
|
|
|
private static final long serialVersionUID = -4123407921997235977L;
|
|
|
|
private static final String ARG_MIMETYPE = "mimetype";
|
|
private static final String ARG_TEMPLATE_PATH = "templatePath";
|
|
private static final String ARG_CONTEXT_PATH = "contextPath";
|
|
|
|
/**
|
|
* Gets the logger to use for this request.
|
|
* <p>
|
|
* This will show all debug entries from this class as though they
|
|
* came from the subclass.
|
|
*
|
|
* @return The logger
|
|
*/
|
|
protected abstract Log getLogger();
|
|
|
|
/**
|
|
* Builds the FreeMarker model
|
|
*
|
|
* @param services Service Registry instance
|
|
* @param req Http request
|
|
* @param templateRef The node ref of the template to process
|
|
* @return The FreeMarker model
|
|
*/
|
|
protected abstract Map<String, Object> buildModel(ServiceRegistry services,
|
|
HttpServletRequest req, NodeRef templateRef);
|
|
|
|
/**
|
|
* Processes the template request using the current context i.e. no
|
|
* authentication checks are made, it is presumed they have already
|
|
* been done.
|
|
*
|
|
* @param req The HTTP request
|
|
* @param res The HTTP response
|
|
* @param redirectToLogin Flag to determine whether to redirect to the login
|
|
* page if the user does not have the correct permissions
|
|
*/
|
|
protected void processTemplateRequest(HttpServletRequest req, HttpServletResponse res,
|
|
boolean redirectToLogin) throws ServletException, IOException
|
|
{
|
|
Log logger = getLogger();
|
|
String uri = req.getRequestURI();
|
|
|
|
if (logger.isDebugEnabled())
|
|
{
|
|
String queryString = req.getQueryString();
|
|
logger.debug("Processing URL: " + uri +
|
|
((queryString != null && queryString.length() > 0) ? ("?" + queryString) : ""));
|
|
}
|
|
|
|
uri = uri.substring(req.getContextPath().length());
|
|
StringTokenizer t = new StringTokenizer(uri, "/");
|
|
int tokenCount = t.countTokens();
|
|
|
|
t.nextToken(); // skip servlet name
|
|
|
|
NodeRef nodeRef = null;
|
|
NodeRef templateRef = null;
|
|
|
|
try
|
|
{
|
|
String contentPath = req.getParameter(ARG_CONTEXT_PATH);
|
|
if (contentPath != null && contentPath.length() != 0)
|
|
{
|
|
// process the name based path to resolve the NodeRef
|
|
PathRefInfo pathInfo = resolveNamePath(getServletContext(), contentPath);
|
|
|
|
nodeRef = pathInfo.NodeRef;
|
|
}
|
|
else if (tokenCount > 3)
|
|
{
|
|
// get NodeRef to the content from the URL elements
|
|
StoreRef storeRef = new StoreRef(t.nextToken(), t.nextToken());
|
|
nodeRef = new NodeRef(storeRef, t.nextToken());
|
|
}
|
|
|
|
// get NodeRef to the template if supplied
|
|
String templatePath = req.getParameter(ARG_TEMPLATE_PATH);
|
|
if (templatePath != null && templatePath.length() != 0)
|
|
{
|
|
// process the name based path to resolve the NodeRef
|
|
PathRefInfo pathInfo = resolveNamePath(getServletContext(), templatePath);
|
|
|
|
templateRef = pathInfo.NodeRef;
|
|
}
|
|
else if (tokenCount >= 7)
|
|
{
|
|
StoreRef storeRef = new StoreRef(t.nextToken(), t.nextToken());
|
|
templateRef = new NodeRef(storeRef, t.nextToken());
|
|
}
|
|
}
|
|
catch (AccessDeniedException err)
|
|
{
|
|
if (redirectToLogin)
|
|
{
|
|
if (logger.isDebugEnabled())
|
|
logger.debug("Redirecting to login page...");
|
|
|
|
redirectToLoginPage(req, res, getServletContext());
|
|
}
|
|
else
|
|
{
|
|
if (logger.isDebugEnabled())
|
|
logger.debug("Returning 403 Forbidden error...");
|
|
|
|
res.sendError(HttpServletResponse.SC_FORBIDDEN);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
// if no context is specified, use the template itself
|
|
// TODO: should this default to something else?
|
|
if (nodeRef == null && templateRef != null)
|
|
{
|
|
nodeRef = templateRef;
|
|
}
|
|
|
|
if (nodeRef == null)
|
|
{
|
|
throw new TemplateException("Not enough elements supplied in URL or no 'path' argument specified.");
|
|
}
|
|
|
|
// get the services we need to retrieve the content
|
|
ServiceRegistry serviceRegistry = getServiceRegistry(getServletContext());
|
|
NodeService nodeService = serviceRegistry.getNodeService();
|
|
TemplateService templateService = serviceRegistry.getTemplateService();
|
|
PermissionService permissionService = serviceRegistry.getPermissionService();
|
|
|
|
// check that the user has at least READ access on any nodes - else redirect to the login page
|
|
if (permissionService.hasPermission(nodeRef, PermissionService.READ) == AccessStatus.DENIED ||
|
|
(templateRef != null && permissionService.hasPermission(templateRef, PermissionService.READ) == AccessStatus.DENIED))
|
|
{
|
|
if (redirectToLogin)
|
|
{
|
|
if (logger.isDebugEnabled())
|
|
logger.debug("Redirecting to login page...");
|
|
|
|
redirectToLoginPage(req, res, getServletContext());
|
|
}
|
|
else
|
|
{
|
|
if (logger.isDebugEnabled())
|
|
logger.debug("Returning 403 Forbidden error...");
|
|
|
|
res.sendError(HttpServletResponse.SC_FORBIDDEN);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
String mimetype = MIMETYPE_HTML;
|
|
if (req.getParameter(ARG_MIMETYPE) != null)
|
|
{
|
|
mimetype = req.getParameter(ARG_MIMETYPE);
|
|
}
|
|
res.setContentType(mimetype);
|
|
|
|
try
|
|
{
|
|
UserTransaction txn = null;
|
|
try
|
|
{
|
|
txn = serviceRegistry.getTransactionService().getUserTransaction(true);
|
|
txn.begin();
|
|
|
|
// if template not supplied, then use the default against the node
|
|
if (templateRef == null)
|
|
{
|
|
if (nodeService.hasAspect(nodeRef, ContentModel.ASPECT_TEMPLATABLE))
|
|
{
|
|
templateRef = (NodeRef)nodeService.getProperty(nodeRef, ContentModel.PROP_TEMPLATE);
|
|
}
|
|
if (templateRef == null)
|
|
{
|
|
throw new TemplateException("Template reference not set against node or not supplied in URL.");
|
|
}
|
|
}
|
|
|
|
// create the model - put the supplied noderef in as space/document as appropriate
|
|
Map<String, Object> model = getModel(serviceRegistry, req, templateRef, nodeRef);
|
|
|
|
// process the template against the node content directly to the response output stream
|
|
// assuming the repo is capable of streaming in chunks, this should allow large files
|
|
// to be streamed directly to the browser response stream.
|
|
try
|
|
{
|
|
templateService.processTemplate(
|
|
templateRef.toString(),
|
|
model,
|
|
res.getWriter());
|
|
|
|
// commit the transaction
|
|
txn.commit();
|
|
}
|
|
catch (SocketException e)
|
|
{
|
|
if (e.getMessage().contains("ClientAbortException"))
|
|
{
|
|
// the client cut the connection - our mission was accomplished apart from a little error message
|
|
logger.error("Client aborted stream read:\n node: " + nodeRef + "\n template: " + templateRef);
|
|
try { if (txn != null) {txn.rollback();} } catch (Exception tex) {}
|
|
}
|
|
else
|
|
{
|
|
throw e;
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
res.getWriter().close();
|
|
}
|
|
}
|
|
catch (Throwable txnErr)
|
|
{
|
|
try { if (txn != null) {txn.rollback();} } catch (Exception tex) {}
|
|
throw txnErr;
|
|
}
|
|
}
|
|
catch (Throwable err)
|
|
{
|
|
throw new AlfrescoRuntimeException("Error during template servlet processing: " + err.getMessage(), err);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Build the model that to process the template against.
|
|
* <p>
|
|
* The model includes the usual template root objects such as 'companyhome', 'userhome',
|
|
* 'person' and also includes the node specified on the servlet URL as 'space' and 'document'
|
|
*
|
|
* @param services ServiceRegistry
|
|
* @param req Http request - for accessing Session and url args
|
|
* @param templateRef NodeRef of the template itself
|
|
* @param nodeRef NodeRef of the space/document to process template against
|
|
*
|
|
* @return an object model ready for executing template against
|
|
*/
|
|
@SuppressWarnings("unchecked")
|
|
private Map<String, Object> getModel(ServiceRegistry services, HttpServletRequest req, NodeRef templateRef, NodeRef nodeRef)
|
|
{
|
|
// build FreeMarker default model and merge
|
|
Map<String, Object> root = buildModel(services, req, templateRef);
|
|
|
|
// put the current NodeRef in as "space" and "document"
|
|
root.put("space", nodeRef);
|
|
root.put("document", nodeRef);
|
|
|
|
// add URL arguments as a map called 'args' to the root of the model
|
|
Map<String, String> args = new HashMap<String, String>(8, 1.0f);
|
|
Enumeration names = req.getParameterNames();
|
|
while (names.hasMoreElements())
|
|
{
|
|
String name = (String)names.nextElement();
|
|
try
|
|
{
|
|
args.put(name, new String(req.getParameter(name).getBytes(), "UTF-8"));
|
|
}
|
|
catch (UnsupportedEncodingException err) {}
|
|
}
|
|
root.put("args", args);
|
|
|
|
// Add the image resolver
|
|
root.put(TemplateService.KEY_IMAGE_RESOLVER, imageResolver);
|
|
|
|
// method to allow client urls to be generated
|
|
root.put("url", new URLHelper(req));
|
|
|
|
return root;
|
|
}
|
|
|
|
/** Template Image resolver helper */
|
|
protected TemplateImageResolver imageResolver = new TemplateImageResolver()
|
|
{
|
|
public String resolveImagePathForName(String filename, FileTypeImageSize size)
|
|
{
|
|
return FileTypeImageUtils.getFileTypeImage(getServletContext(), filename, size);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Helper to return context path for generating urls
|
|
*/
|
|
public static class URLHelper
|
|
{
|
|
String contextPath;
|
|
String serverPath;
|
|
|
|
public URLHelper(HttpServletRequest request)
|
|
{
|
|
this.contextPath = request.getContextPath();
|
|
this.serverPath = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort();
|
|
}
|
|
|
|
public URLHelper(FacesContext context)
|
|
{
|
|
this.contextPath = context.getExternalContext().getRequestContextPath();
|
|
final Object request = context.getExternalContext().getRequest();
|
|
if (request instanceof HttpServletRequest)
|
|
{
|
|
final HttpServletRequest httpServletRequest = (HttpServletRequest) request;
|
|
this.serverPath = httpServletRequest.getScheme() + "://" + httpServletRequest.getServerName() + ":" + httpServletRequest.getServerPort();
|
|
}
|
|
}
|
|
|
|
public String getContext()
|
|
{
|
|
return this.contextPath;
|
|
}
|
|
|
|
public String getServerPath()
|
|
{
|
|
return this.serverPath;
|
|
}
|
|
}
|
|
}
|