001    /**
002     * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.upload;
016    
017    import com.liferay.portal.kernel.upload.FileItem;
018    import com.liferay.portal.kernel.upload.UploadPortletRequest;
019    import com.liferay.portal.kernel.upload.UploadServletRequest;
020    import com.liferay.portal.kernel.util.ContentTypes;
021    import com.liferay.portal.kernel.util.MimeTypesUtil;
022    import com.liferay.portal.kernel.util.Validator;
023    
024    import java.io.File;
025    import java.io.IOException;
026    import java.io.InputStream;
027    
028    import java.util.ArrayList;
029    import java.util.Collections;
030    import java.util.Enumeration;
031    import java.util.HashMap;
032    import java.util.List;
033    import java.util.Map;
034    
035    import javax.portlet.PortletRequest;
036    
037    import javax.servlet.http.HttpServletRequestWrapper;
038    
039    /**
040     * @author Brian Wing Shun Chan
041     * @author Harry Mark
042     */
043    public class UploadPortletRequestImpl
044            extends HttpServletRequestWrapper implements UploadPortletRequest {
045    
046            /**
047             * @deprecated As of 7.0.0, replaced by {@link #UploadPortletRequestImpl(
048             *             UploadServletRequest, PortletRequest, String)}
049             */
050            public UploadPortletRequestImpl(
051                    UploadServletRequest uploadServletRequest, String namespace) {
052    
053                    super(uploadServletRequest);
054    
055                    _uploadServletRequest = uploadServletRequest;
056                    _namespace = namespace;
057            }
058    
059            public UploadPortletRequestImpl(
060                    UploadServletRequest uploadServletRequest,
061                    PortletRequest portletRequest, String namespace) {
062    
063                    super(uploadServletRequest);
064    
065                    _uploadServletRequest = uploadServletRequest;
066                    _portletRequest = portletRequest;
067                    _namespace = namespace;
068            }
069    
070            @Override
071            public void cleanUp() {
072                    _uploadServletRequest.cleanUp();
073            }
074    
075            @Override
076            public String getContentType(String name) {
077                    String contentType = _uploadServletRequest.getContentType(
078                            _namespace.concat(name));
079    
080                    if (contentType == null) {
081                            contentType = _uploadServletRequest.getContentType(name);
082                    }
083    
084                    if (Validator.isNull(contentType) ||
085                            contentType.equals(ContentTypes.APPLICATION_OCTET_STREAM)) {
086    
087                            contentType = MimeTypesUtil.getContentType(getFile(name));
088                    }
089    
090                    return contentType;
091            }
092    
093            @Override
094            public File getFile(String name) {
095                    return getFile(name, false);
096            }
097    
098            @Override
099            public File getFile(String name, boolean forceCreate) {
100                    File file = _uploadServletRequest.getFile(
101                            _namespace.concat(name), forceCreate);
102    
103                    if (file == null) {
104                            file = _uploadServletRequest.getFile(name, forceCreate);
105                    }
106    
107                    return file;
108            }
109    
110            @Override
111            public InputStream getFileAsStream(String name) throws IOException {
112                    return getFileAsStream(name, true);
113            }
114    
115            @Override
116            public InputStream getFileAsStream(String name, boolean deleteOnClose)
117                    throws IOException {
118    
119                    InputStream inputStream = _uploadServletRequest.getFileAsStream(
120                            _namespace.concat(name), deleteOnClose);
121    
122                    if (inputStream == null) {
123                            inputStream = _uploadServletRequest.getFileAsStream(
124                                    name, deleteOnClose);
125                    }
126    
127                    return inputStream;
128            }
129    
130            @Override
131            public String getFileName(String name) {
132                    String fileName = _uploadServletRequest.getFileName(
133                            _namespace.concat(name));
134    
135                    if (fileName == null) {
136                            fileName = _uploadServletRequest.getFileName(name);
137                    }
138    
139                    return fileName;
140            }
141    
142            @Override
143            public String[] getFileNames(String name) {
144                    String[] fileNames = _uploadServletRequest.getFileNames(
145                            _namespace.concat(name));
146    
147                    if (fileNames == null) {
148                            fileNames = _uploadServletRequest.getFileNames(name);
149                    }
150    
151                    return fileNames;
152            }
153    
154            @Override
155            public File[] getFiles(String name) {
156                    File[] files = _uploadServletRequest.getFiles(_namespace.concat(name));
157    
158                    if (files == null) {
159                            files = _uploadServletRequest.getFiles(name);
160                    }
161    
162                    return files;
163            }
164    
165            @Override
166            public InputStream[] getFilesAsStream(String name) throws IOException {
167                    return getFilesAsStream(name, true);
168            }
169    
170            @Override
171            public InputStream[] getFilesAsStream(String name, boolean deleteOnClose)
172                    throws IOException {
173    
174                    InputStream[] inputStreams = _uploadServletRequest.getFilesAsStream(
175                            _namespace.concat(name), deleteOnClose);
176    
177                    if (inputStreams == null) {
178                            inputStreams = _uploadServletRequest.getFilesAsStream(
179                                    name, deleteOnClose);
180                    }
181    
182                    return inputStreams;
183            }
184    
185            @Override
186            public String getFullFileName(String name) {
187                    String fullFileName = _uploadServletRequest.getFullFileName(
188                            _namespace.concat(name));
189    
190                    if (fullFileName == null) {
191                            fullFileName = _uploadServletRequest.getFullFileName(name);
192                    }
193    
194                    return fullFileName;
195            }
196    
197            @Override
198            public Map<String, FileItem[]> getMultipartParameterMap() {
199                    if (!(_uploadServletRequest instanceof UploadServletRequestImpl)) {
200                            return Collections.emptyMap();
201                    }
202    
203                    Map<String, FileItem[]> map = new HashMap<String, FileItem[]>();
204    
205                    UploadServletRequestImpl uploadServletRequestImpl =
206                            (UploadServletRequestImpl)_uploadServletRequest;
207    
208                    Map<String, FileItem[]> multipartParameterMap =
209                            uploadServletRequestImpl.getMultipartParameterMap();
210    
211                    for (String name : multipartParameterMap.keySet()) {
212                            if (name.startsWith(_namespace)) {
213                                    map.put(
214                                            name.substring(_namespace.length(), name.length()),
215                                            multipartParameterMap.get(name));
216                            }
217                            else {
218                                    map.put(name, multipartParameterMap.get(name));
219                            }
220                    }
221    
222                    return map;
223            }
224    
225            @Override
226            public String getParameter(String name) {
227                    String parameter = _uploadServletRequest.getParameter(
228                            _namespace.concat(name));
229    
230                    if (parameter == null) {
231                            parameter = _uploadServletRequest.getParameter(name);
232                    }
233    
234                    return parameter;
235            }
236    
237            @Override
238            public Map<String, String[]> getParameterMap() {
239                    Map<String, String[]> map = new HashMap<String, String[]>();
240    
241                    Enumeration<String> enu = getParameterNames();
242    
243                    while (enu.hasMoreElements()) {
244                            String name = enu.nextElement();
245    
246                            map.put(name, getParameterValues(name));
247                    }
248    
249                    return map;
250            }
251    
252            @Override
253            public Enumeration<String> getParameterNames() {
254                    List<String> parameterNames = new ArrayList<String>();
255    
256                    Enumeration<String> enu = _uploadServletRequest.getParameterNames();
257    
258                    while (enu.hasMoreElements()) {
259                            String name = enu.nextElement();
260    
261                            if (name.startsWith(_namespace)) {
262                                    parameterNames.add(name.substring(_namespace.length()));
263                            }
264                            else {
265                                    parameterNames.add(name);
266                            }
267                    }
268    
269                    return Collections.enumeration(parameterNames);
270            }
271    
272            @Override
273            public String[] getParameterValues(String name) {
274                    String[] parameterValues = _uploadServletRequest.getParameterValues(
275                            _namespace.concat(name));
276    
277                    if (parameterValues == null) {
278                            parameterValues = _uploadServletRequest.getParameterValues(name);
279                    }
280    
281                    return parameterValues;
282            }
283    
284            @Override
285            public PortletRequest getPortletRequest() {
286                    return _portletRequest;
287            }
288    
289            @Override
290            public Map<String, List<String>> getRegularParameterMap() {
291                    if (!(_uploadServletRequest instanceof UploadServletRequestImpl)) {
292                            return Collections.emptyMap();
293                    }
294    
295                    Map<String, List<String>> map = new HashMap<String, List<String>>();
296    
297                    UploadServletRequestImpl uploadServletRequestImpl =
298                            (UploadServletRequestImpl)_uploadServletRequest;
299    
300                    Map<String, List<String>> regularParameterMap =
301                            uploadServletRequestImpl.getRegularParameterMap();
302    
303                    for (String name : regularParameterMap.keySet()) {
304                            if (name.startsWith(_namespace)) {
305                                    map.put(
306                                            name.substring(_namespace.length(), name.length()),
307                                            regularParameterMap.get(name));
308                            }
309                            else {
310                                    map.put(name, regularParameterMap.get(name));
311                            }
312                    }
313    
314                    return map;
315            }
316    
317            @Override
318            public Long getSize(String name) {
319                    Long size = _uploadServletRequest.getSize(_namespace.concat(name));
320    
321                    if (size == null) {
322                            size = _uploadServletRequest.getSize(name);
323                    }
324    
325                    if (size == null) {
326                            return Long.valueOf(0);
327                    }
328    
329                    return size;
330            }
331    
332            @Override
333            public Boolean isFormField(String name) {
334                    Boolean formField = _uploadServletRequest.isFormField(
335                            _namespace.concat(name));
336    
337                    if (formField == null) {
338                            formField = _uploadServletRequest.isFormField(name);
339                    }
340    
341                    if (formField == null) {
342                            return true;
343                    }
344                    else {
345                            return formField.booleanValue();
346                    }
347            }
348    
349            private String _namespace;
350            private PortletRequest _portletRequest;
351            private UploadServletRequest _uploadServletRequest;
352    
353    }