1   /**
2    * Copyright (c) 2000-2009 Liferay, Inc. All rights reserved.
3    *
4    *
5    *
6    *
7    * The contents of this file are subject to the terms of the Liferay Enterprise
8    * Subscription License ("License"). You may not use this file except in
9    * compliance with the License. You can obtain a copy of the License by
10   * contacting Liferay, Inc. See the License for the specific language governing
11   * permissions and limitations under the License, including but not limited to
12   * distribution rights of the Software.
13   *
14   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20   * SOFTWARE.
21   */
22  
23  package com.liferay.portlet;
24  
25  import com.liferay.util.servlet.NullServletOutputStream;
26  
27  import java.io.IOException;
28  import java.io.PrintWriter;
29  
30  import java.util.Locale;
31  
32  import javax.portlet.ActionResponse;
33  import javax.portlet.MimeResponse;
34  import javax.portlet.PortletRequest;
35  
36  import javax.servlet.ServletOutputStream;
37  import javax.servlet.http.Cookie;
38  import javax.servlet.http.HttpServletResponse;
39  import javax.servlet.http.HttpServletResponseWrapper;
40  
41  /**
42   * <a href="PortletServletResponse.java.html"><b><i>View Source</i></b></a>
43   *
44   * @author Brian Wing Shun Chan
45   */
46  public class PortletServletResponse extends HttpServletResponseWrapper {
47  
48      public PortletServletResponse(
49          HttpServletResponse response, PortletResponseImpl portletResponseImpl,
50          boolean include) {
51  
52          super(response);
53  
54          _response = response;
55          _portletResponseImpl = portletResponseImpl;
56          _include = include;
57          _lifecycle = _portletResponseImpl.getLifecycle();
58      }
59  
60      public void addCookie(Cookie cookie) {
61          if (!_include) {
62              _portletResponseImpl.addProperty(cookie);
63          }
64      }
65  
66      public void addDateHeader(String name, long date) {
67          addHeader(name, String.valueOf(date));
68      }
69  
70      public void addHeader(String name, String value) {
71          if (!_include) {
72              if (_lifecycle.equals(PortletRequest.RENDER_PHASE) ||
73                  _lifecycle.equals(PortletRequest.RESOURCE_PHASE)) {
74  
75                  HttpServletResponse response =
76                      _portletResponseImpl.getHttpServletResponse();
77  
78                  response.addHeader(name, value);
79              }
80          }
81      }
82  
83      public void addIntHeader(String name, int value) {
84          addHeader(name, String.valueOf(value));
85      }
86  
87      public boolean containsHeader(String name) {
88          return false;
89      }
90  
91      public String encodeRedirectURL(String url) {
92          return null;
93      }
94  
95      public String encodeRedirectUrl(String url) {
96          return null;
97      }
98  
99      public String encodeURL(String url) {
100         return _portletResponseImpl.encodeURL(url);
101     }
102 
103     public String encodeUrl(String url) {
104         return _portletResponseImpl.encodeURL(url);
105     }
106 
107     public void flushBuffer() throws IOException {
108         if (_lifecycle.equals(PortletRequest.RENDER_PHASE) ||
109             _lifecycle.equals(PortletRequest.RESOURCE_PHASE)) {
110 
111             _response.flushBuffer();
112         }
113     }
114 
115     public int getBufferSize() {
116         if (_lifecycle.equals(PortletRequest.RENDER_PHASE) ||
117             _lifecycle.equals(PortletRequest.RESOURCE_PHASE)) {
118 
119             return _response.getBufferSize();
120         }
121         else {
122             return 0;
123         }
124     }
125 
126     public String getCharacterEncoding() {
127         if (_lifecycle.equals(PortletRequest.RENDER_PHASE) ||
128             _lifecycle.equals(PortletRequest.RESOURCE_PHASE)) {
129 
130             return _response.getCharacterEncoding();
131         }
132         else {
133             return null;
134         }
135     }
136 
137     public String getContentType() {
138         if (_lifecycle.equals(PortletRequest.RENDER_PHASE) ||
139             _lifecycle.equals(PortletRequest.RESOURCE_PHASE)) {
140 
141             return ((MimeResponse)_portletResponseImpl).getContentType();
142         }
143         else {
144             return null;
145         }
146     }
147 
148     public Locale getLocale() {
149         if (_lifecycle.equals(PortletRequest.RENDER_PHASE) ||
150             _lifecycle.equals(PortletRequest.RESOURCE_PHASE)) {
151 
152             return _response.getLocale();
153         }
154         else {
155             return null;
156         }
157     }
158 
159     public ServletOutputStream getOutputStream() throws IOException {
160         if (_lifecycle.equals(PortletRequest.RENDER_PHASE) ||
161             _lifecycle.equals(PortletRequest.RESOURCE_PHASE)) {
162 
163             return _response.getOutputStream();
164         }
165         else {
166             return new NullServletOutputStream();
167         }
168     }
169 
170     public PrintWriter getWriter() throws IOException {
171         if (_lifecycle.equals(PortletRequest.RENDER_PHASE) ||
172             _lifecycle.equals(PortletRequest.RESOURCE_PHASE)) {
173 
174             return _response.getWriter();
175         }
176         else {
177             return new PrintWriter(new NullServletOutputStream());
178         }
179     }
180 
181     public boolean isCommitted() {
182         if (!_include) {
183             if (_lifecycle.equals(PortletRequest.RENDER_PHASE) ||
184                 _lifecycle.equals(PortletRequest.RESOURCE_PHASE)) {
185 
186                 return _response.isCommitted();
187             }
188             else {
189                 return false;
190             }
191         }
192         else {
193             if (_lifecycle.equals(PortletRequest.RENDER_PHASE) ||
194                 _lifecycle.equals(PortletRequest.RESOURCE_PHASE)) {
195 
196                 return _response.isCommitted();
197             }
198             else {
199                 return true;
200             }
201         }
202     }
203 
204     public void reset() {
205         if (_lifecycle.equals(PortletRequest.RENDER_PHASE) ||
206             _lifecycle.equals(PortletRequest.RESOURCE_PHASE)) {
207 
208             _response.reset();
209         }
210     }
211 
212     public void resetBuffer() {
213         if (_lifecycle.equals(PortletRequest.RENDER_PHASE) ||
214             _lifecycle.equals(PortletRequest.RESOURCE_PHASE)) {
215 
216             _response.resetBuffer();
217         }
218     }
219 
220     public void sendError(int sc) {
221     }
222 
223     public void sendError(int sc, String msg) {
224     }
225 
226     public void sendRedirect(String location) throws IOException {
227         if (!_include) {
228             if (_lifecycle.equals(PortletRequest.ACTION_PHASE)) {
229                 ((ActionResponse)_portletResponseImpl).sendRedirect(location);
230             }
231         }
232     }
233 
234     public void setBufferSize(int bufferSize) {
235         if (_lifecycle.equals(PortletRequest.RENDER_PHASE) ||
236             _lifecycle.equals(PortletRequest.RESOURCE_PHASE)) {
237 
238             _response.setBufferSize(bufferSize);
239         }
240     }
241 
242     public void setCharacterEncoding(String encoding) {
243         if (!_include) {
244             if (_lifecycle.equals(PortletRequest.RESOURCE_PHASE)) {
245                 _response.setCharacterEncoding(encoding);
246             }
247         }
248     }
249 
250     public void setContentLength(int length) {
251         if (!_include) {
252             if (_lifecycle.equals(PortletRequest.RESOURCE_PHASE)) {
253                 _response.setContentLength(length);
254             }
255         }
256     }
257 
258     public void setContentType(String contentType) {
259         if (!_include) {
260             if (_lifecycle.equals(PortletRequest.RENDER_PHASE) ||
261                 _lifecycle.equals(PortletRequest.RESOURCE_PHASE)) {
262 
263                 ((MimeResponse)_portletResponseImpl).setContentType(
264                     contentType);
265             }
266         }
267     }
268 
269     public void setDateHeader(String name, long date) {
270         setHeader(name, String.valueOf(date));
271     }
272 
273     public void setHeader(String name, String value) {
274         if (!_include) {
275             if (_lifecycle.equals(PortletRequest.RENDER_PHASE) ||
276                 _lifecycle.equals(PortletRequest.RESOURCE_PHASE)) {
277 
278                 HttpServletResponse response =
279                     _portletResponseImpl.getHttpServletResponse();
280 
281                 response.setHeader(name, value);
282             }
283         }
284     }
285 
286     public void setIntHeader(String name, int value) {
287         setHeader(name, String.valueOf(value));
288     }
289 
290     public void setLocale(Locale locale) {
291         if (!_include) {
292             if (_lifecycle.equals(PortletRequest.RESOURCE_PHASE)) {
293                 _response.setLocale(locale);
294             }
295         }
296     }
297 
298     public void setStatus(int sc) {
299         if (!_include) {
300             if (_lifecycle.equals(PortletRequest.RESOURCE_PHASE)) {
301                 _response.setStatus(sc);
302             }
303         }
304     }
305 
306     public void setStatus(int sc, String msg) {
307         setStatus(sc);
308     }
309 
310     private HttpServletResponse _response;
311     private PortletResponseImpl _portletResponseImpl;
312     private boolean _include;
313     private String _lifecycle;
314 
315 }