/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.sling.scripting.jsp.taglib;
import java.io.IOException;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.JspTagException;
import javax.servlet.jsp.PageContext;
import javax.servlet.jsp.tagext.TagSupport;
import org.apache.sling.api.SlingHttpServletRequest;
import org.apache.sling.api.SlingHttpServletResponse;
import org.apache.sling.api.request.RequestDispatcherOptions;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.api.resource.ResourceResolver;
import org.apache.sling.api.resource.ResourceUtil;
import org.apache.sling.api.resource.SyntheticResource;
import org.apache.sling.scripting.jsp.util.JspSlingHttpServletResponseWrapper;
import org.apache.sling.scripting.jsp.util.TagUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* The <code>IncludeTagHandler</code> implements the
* <code><sling:include></code> custom tag.
*/
public abstract class AbstractDispatcherTagHandler extends TagSupport {
private static final long serialVersionUID = 6275972595573203863L;
/** default log */
private static final Logger log = LoggerFactory.getLogger(AbstractDispatcherTagHandler.class);
/** resource argument */
private Resource resource;
/** path argument */
private String path;
/** resource type argument */
private String resourceType;
/** replace selectors argument */
private String replaceSelectors;
/** additional selectors argument */
private String addSelectors;
/** replace suffix argument */
private String replaceSuffix;
/**
* Called after the body has been processed.
*
* @return whether additional evaluations of the body are desired
*/
public int doEndTag() throws JspException {
log.debug("AbstractDispatcherTagHandler.doEndTag");
final SlingHttpServletRequest request = TagUtil.getRequest(pageContext);
// set request dispatcher options according to tag attributes. This
// depends on the implementation, that using a "null" argument
// has no effect
final RequestDispatcherOptions opts = new RequestDispatcherOptions();
opts.setForceResourceType(resourceType);
opts.setReplaceSelectors(replaceSelectors);
opts.setAddSelectors(addSelectors);
opts.setReplaceSuffix(replaceSuffix);
// ensure the path (if set) is absolute and normalized
if (path != null) {
if (!path.startsWith("/")) {
path = request.getResource().getPath() + "/" + path;
}
path = ResourceUtil.normalize(path);
}
// check the resource
if (resource == null) {
if (path == null) {
// neither resource nor path is defined, use current resource
resource = request.getResource();
} else {
// check whether the path (would) resolve, else SyntheticRes.
Resource tmp = request.getResourceResolver().resolve(path);
if (tmp == null && resourceType != null) {
resource = new DispatcherSyntheticResource(
request.getResourceResolver(), path, resourceType);
// remove resource type overwrite as synthetic resource
// is correctly typed as requested
opts.remove(RequestDispatcherOptions.OPT_FORCE_RESOURCE_TYPE);
}
}
}
try {
// create a dispatcher for the resource or path
RequestDispatcher dispatcher;
if (resource != null) {
dispatcher = request.getRequestDispatcher(resource, opts);
} else {
dispatcher = request.getRequestDispatcher(path, opts);
}
if (dispatcher != null) {
SlingHttpServletResponse response = new JspSlingHttpServletResponseWrapper(
pageContext);
dispatch(dispatcher, request, response);
} else {
TagUtil.log(log, pageContext, "No content to include...", null);
}
} catch (final JspTagException jte) {
throw jte;
} catch (final IOException ioe) {
throw new JspTagException(ioe);
} catch (final ServletException ce) {
throw new JspTagException(TagUtil.getRootCause(ce));
}
return EVAL_PAGE;
}
protected abstract void dispatch(RequestDispatcher dispatcher,
ServletRequest request, ServletResponse response)
throws IOException, ServletException, JspTagException;
public void setPageContext(PageContext pageContext) {
super.setPageContext(pageContext);
clear();
}
public void setResource(final Resource rsrc) {
if ( rsrc == null ) {
throw new NullPointerException("Resource should not be null.");
}
this.resource = rsrc;
}
public void setPath(String path) {
this.path = path;
}
public void setResourceType(String rsrcType) {
this.resourceType = rsrcType;
}
public void setReplaceSelectors(String selectors) {
this.replaceSelectors = selectors;
}
public void setAddSelectors(String selectors) {
this.addSelectors = selectors;
}
public void setReplaceSuffix(String suffix) {
this.replaceSuffix = suffix;
}
/**
* The <code>DispatcherSyntheticResource</code> extends the
* <code>SyntheticResource</code> class overwriting the
* {@link #getResourceSuperType()} method to provide a possibly non-
* <code>null</code> result.
*/
private static class DispatcherSyntheticResource extends SyntheticResource {
public DispatcherSyntheticResource(ResourceResolver resourceResolver,
String path, String resourceType) {
super(resourceResolver, path, resourceType);
}
@Override
public String getResourceSuperType() {
return ResourceUtil.getResourceSuperType(getResourceResolver(),
getResourceType());
}
}
@Override
public void release() {
clear();
super.release();
}
private void clear() {
resource = null;
resourceType = null;
replaceSelectors = null;
addSelectors = null;
replaceSuffix = null;
path = null;
}
}