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