001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one or more
003: * contributor license agreements. See the NOTICE file distributed with
004: * this work for additional information regarding copyright ownership.
005: * The ASF licenses this file to You under the Apache License, Version 2.0
006: * (the "License"); you may not use this file except in compliance with
007: * the License. You may obtain a copy of the License at
008: *
009: * http://www.apache.org/licenses/LICENSE-2.0
010: *
011: * Unless required by applicable law or agreed to in writing, software
012: * distributed under the License is distributed on an "AS IS" BASIS,
013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014: * See the License for the specific language governing permissions and
015: * limitations under the License.
016: *
017: * $Header:$
018: */
019: package org.apache.beehive.netui.pageflow.internal;
020:
021: import javax.servlet.ServletContext;
022: import javax.servlet.ServletRequest;
023: import javax.servlet.ServletResponse;
024: import javax.servlet.http.HttpServletRequest;
025:
026: import org.apache.beehive.netui.core.urls.MutableURI;
027: import org.apache.beehive.netui.core.urls.URLRewriter;
028: import org.apache.beehive.netui.core.urls.URLType;
029: import org.apache.beehive.netui.core.urls.AjaxUrlInfo;
030: import org.apache.beehive.netui.pageflow.ServletContainerAdapter;
031: import org.apache.beehive.netui.pageflow.requeststate.INameable;
032: import org.apache.beehive.netui.pageflow.scoping.ScopedServletUtils;
033: import org.apache.beehive.netui.util.logging.Logger;
034:
035: public class DefaultURLRewriter extends URLRewriter {
036: private static final Logger _log = Logger
037: .getInstance(DefaultURLRewriter.class);
038:
039: public String getNamePrefix(ServletContext servletContext,
040: ServletRequest request, String name) {
041: return "";
042: }
043:
044: /**
045: * This method will get the prefix for all URLs that are used for AJAX processing
046: * @param servletContext the current ServletContext.
047: * @param request the current ServletRequest.
048: * @param nameable the INamable object that will handle the request
049: */
050: public AjaxUrlInfo getAjaxUrl(ServletContext servletContext,
051: ServletRequest request, Object nameable) {
052: HttpServletRequest req = (HttpServletRequest) request;
053: // the default behavior is to set the parameter as the nameable's name or null
054: String name = null;
055: if (nameable instanceof INameable)
056: name = ((INameable) nameable).getObjectName();
057:
058: String path = req.getServletPath();
059: int idx = path.lastIndexOf('/');
060: if (idx != -1) {
061: path = "/" + path.substring(1, idx);
062: }
063:
064: path = req.getContextPath() + path;
065: return new AjaxUrlInfo(path, name);
066: }
067:
068: public void rewriteURL(ServletContext servletContext,
069: ServletRequest request, ServletResponse response,
070: MutableURI url, URLType type, boolean needsToBeSecure) {
071: ServletContainerAdapter servletContainerAdapter = AdapterManager
072: .getServletContainerAdapter(servletContext);
073:
074: // If url is not absolute, then do default secure/unsecure rewriting
075: if (!url.isAbsolute()) {
076: if (needsToBeSecure) {
077: if (!request.isSecure()) {
078: int securePort = servletContainerAdapter
079: .getSecureListenPort((HttpServletRequest) request);
080:
081: if (securePort != -1) {
082: internalRewriteUrl(url, "https", securePort,
083: request.getServerName());
084: } else {
085: if (_log.isWarnEnabled()) {
086: _log
087: .warn("Could not rewrite URL "
088: + url.getURIString(null)
089: + " to be secure because"
090: + " a secure port was not provided by the ServletContainerAdapter.");
091: }
092: }
093: }
094: } else {
095: if (request.isSecure()) {
096: int listenPort = servletContainerAdapter
097: .getListenPort((HttpServletRequest) request);
098:
099: if (listenPort != -1) {
100: internalRewriteUrl(url, "http", listenPort,
101: request.getServerName());
102: } else {
103: if (_log.isWarnEnabled()) {
104: _log
105: .warn("Could not rewrite URL "
106: + url.getURIString(null)
107: + " to be non-secure"
108: + " because a port was not provided by the ServletContainerAdapter.");
109: }
110: }
111: }
112: }
113: }
114:
115: //
116: // If the current request has a special parameter that addresses a named 'scope',
117: // add the parameter to the URL.
118: //
119: String scopeID = request
120: .getParameter(ScopedServletUtils.SCOPE_ID_PARAM);
121: if (scopeID != null) {
122: // check to see if the param is already there.
123: if (url.getParameter(ScopedServletUtils.SCOPE_ID_PARAM) == null) {
124: url.addParameter(ScopedServletUtils.SCOPE_ID_PARAM,
125: scopeID, true);
126: }
127: }
128: }
129:
130: private static void internalRewriteUrl(MutableURI url,
131: String protocol, int port, String serverName) {
132: // Need to build up the url
133: url.setScheme(protocol);
134: url.setHost(serverName);
135: url.setPort(port);
136: }
137:
138: /**
139: * Determines if the passed-in Object is equivalent to this DefaultURLRewriter.
140: * Since there is no member data for this class they will all be equal.
141: *
142: * @param object the Object to test for equality.
143: * @return true if object is another instance of DefaultURLRewriter.
144: */
145:
146: public boolean equals(Object object) {
147: if (object == this ) {
148: return true;
149: }
150:
151: if (object == null
152: || !object.getClass().equals(this .getClass())) {
153: return false;
154: }
155:
156: return true;
157: }
158:
159: /**
160: * Returns a hash code value for the object.
161: * Implemented in conjunction with equals() override.
162: * Since there is no member data for this class we
163: * always return the same value.
164: *
165: * @return a hash code value for this object.
166: */
167:
168: public int hashCode() {
169: return 0;
170: }
171: }
|