001    /**
002     * Copyright (c) 2000-present 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            public UploadPortletRequestImpl(
047                    UploadServletRequest uploadServletRequest,
048                    PortletRequest portletRequest, String namespace) {
049    
050                    super(uploadServletRequest);
051    
052                    _uploadServletRequest = uploadServletRequest;
053                    _portletRequest = portletRequest;
054                    _namespace = namespace;
055            }
056    
057            @Override
058            public void cleanUp() {
059                    _uploadServletRequest.cleanUp();
060            }
061    
062            @Override
063            public String getContentType(String name) {
064                    String contentType = _uploadServletRequest.getContentType(
065                            _namespace.concat(name));
066    
067                    if (contentType == null) {
068                            contentType = _uploadServletRequest.getContentType(name);
069                    }
070    
071                    if (Validator.isNull(contentType) ||
072                            contentType.equals(ContentTypes.APPLICATION_OCTET_STREAM)) {
073    
074                            File file = getFile(name);
075    
076                            if (file != null) {
077                                    contentType = MimeTypesUtil.getContentType(file);
078                            }
079                    }
080    
081                    return contentType;
082            }
083    
084            @Override
085            public File getFile(String name) {
086                    return getFile(name, false);
087            }
088    
089            @Override
090            public File getFile(String name, boolean forceCreate) {
091                    File file = _uploadServletRequest.getFile(
092                            _namespace.concat(name), forceCreate);
093    
094                    if (file == null) {
095                            file = _uploadServletRequest.getFile(name, forceCreate);
096                    }
097    
098                    return file;
099            }
100    
101            @Override
102            public InputStream getFileAsStream(String name) throws IOException {
103                    return getFileAsStream(name, true);
104            }
105    
106            @Override
107            public InputStream getFileAsStream(String name, boolean deleteOnClose)
108                    throws IOException {
109    
110                    InputStream inputStream = _uploadServletRequest.getFileAsStream(
111                            _namespace.concat(name), deleteOnClose);
112    
113                    if (inputStream == null) {
114                            inputStream = _uploadServletRequest.getFileAsStream(
115                                    name, deleteOnClose);
116                    }
117    
118                    return inputStream;
119            }
120    
121            @Override
122            public String getFileName(String name) {
123                    String fileName = _uploadServletRequest.getFileName(
124                            _namespace.concat(name));
125    
126                    if (fileName == null) {
127                            fileName = _uploadServletRequest.getFileName(name);
128                    }
129    
130                    return fileName;
131            }
132    
133            @Override
134            public String[] getFileNames(String name) {
135                    String[] fileNames = _uploadServletRequest.getFileNames(
136                            _namespace.concat(name));
137    
138                    if (fileNames == null) {
139                            fileNames = _uploadServletRequest.getFileNames(name);
140                    }
141    
142                    return fileNames;
143            }
144    
145            @Override
146            public File[] getFiles(String name) {
147                    File[] files = _uploadServletRequest.getFiles(_namespace.concat(name));
148    
149                    if (files == null) {
150                            files = _uploadServletRequest.getFiles(name);
151                    }
152    
153                    return files;
154            }
155    
156            @Override
157            public InputStream[] getFilesAsStream(String name) throws IOException {
158                    return getFilesAsStream(name, true);
159            }
160    
161            @Override
162            public InputStream[] getFilesAsStream(String name, boolean deleteOnClose)
163                    throws IOException {
164    
165                    InputStream[] inputStreams = _uploadServletRequest.getFilesAsStream(
166                            _namespace.concat(name), deleteOnClose);
167    
168                    if (inputStreams == null) {
169                            inputStreams = _uploadServletRequest.getFilesAsStream(
170                                    name, deleteOnClose);
171                    }
172    
173                    return inputStreams;
174            }
175    
176            @Override
177            public String getFullFileName(String name) {
178                    String fullFileName = _uploadServletRequest.getFullFileName(
179                            _namespace.concat(name));
180    
181                    if (fullFileName == null) {
182                            fullFileName = _uploadServletRequest.getFullFileName(name);
183                    }
184    
185                    return fullFileName;
186            }
187    
188            @Override
189            public Map<String, FileItem[]> getMultipartParameterMap() {
190                    if (!(_uploadServletRequest instanceof UploadServletRequestImpl)) {
191                            return Collections.emptyMap();
192                    }
193    
194                    Map<String, FileItem[]> map = new HashMap<>();
195    
196                    UploadServletRequestImpl uploadServletRequestImpl =
197                            (UploadServletRequestImpl)_uploadServletRequest;
198    
199                    Map<String, FileItem[]> multipartParameterMap =
200                            uploadServletRequestImpl.getMultipartParameterMap();
201    
202                    for (String name : multipartParameterMap.keySet()) {
203                            if (name.startsWith(_namespace)) {
204                                    map.put(
205                                            name.substring(_namespace.length(), name.length()),
206                                            multipartParameterMap.get(name));
207                            }
208                            else {
209                                    map.put(name, multipartParameterMap.get(name));
210                            }
211                    }
212    
213                    return map;
214            }
215    
216            @Override
217            public String getParameter(String name) {
218                    String parameter = _uploadServletRequest.getParameter(
219                            _namespace.concat(name));
220    
221                    if (parameter == null) {
222                            parameter = _uploadServletRequest.getParameter(name);
223                    }
224    
225                    return parameter;
226            }
227    
228            @Override
229            public Map<String, String[]> getParameterMap() {
230                    Map<String, String[]> map = new HashMap<>();
231    
232                    Enumeration<String> enu = getParameterNames();
233    
234                    while (enu.hasMoreElements()) {
235                            String name = enu.nextElement();
236    
237                            map.put(name, getParameterValues(name));
238                    }
239    
240                    return map;
241            }
242    
243            @Override
244            public Enumeration<String> getParameterNames() {
245                    List<String> parameterNames = new ArrayList<>();
246    
247                    Enumeration<String> enu = _uploadServletRequest.getParameterNames();
248    
249                    while (enu.hasMoreElements()) {
250                            String name = enu.nextElement();
251    
252                            if (name.startsWith(_namespace)) {
253                                    parameterNames.add(name.substring(_namespace.length()));
254                            }
255                            else {
256                                    parameterNames.add(name);
257                            }
258                    }
259    
260                    return Collections.enumeration(parameterNames);
261            }
262    
263            @Override
264            public String[] getParameterValues(String name) {
265                    String[] parameterValues = _uploadServletRequest.getParameterValues(
266                            _namespace.concat(name));
267    
268                    if (parameterValues == null) {
269                            parameterValues = _uploadServletRequest.getParameterValues(name);
270                    }
271    
272                    return parameterValues;
273            }
274    
275            @Override
276            public PortletRequest getPortletRequest() {
277                    return _portletRequest;
278            }
279    
280            @Override
281            public Map<String, List<String>> getRegularParameterMap() {
282                    if (!(_uploadServletRequest instanceof UploadServletRequestImpl)) {
283                            return Collections.emptyMap();
284                    }
285    
286                    Map<String, List<String>> map = new HashMap<>();
287    
288                    UploadServletRequestImpl uploadServletRequestImpl =
289                            (UploadServletRequestImpl)_uploadServletRequest;
290    
291                    Map<String, List<String>> regularParameterMap =
292                            uploadServletRequestImpl.getRegularParameterMap();
293    
294                    for (String name : regularParameterMap.keySet()) {
295                            if (name.startsWith(_namespace)) {
296                                    map.put(
297                                            name.substring(_namespace.length(), name.length()),
298                                            regularParameterMap.get(name));
299                            }
300                            else {
301                                    map.put(name, regularParameterMap.get(name));
302                            }
303                    }
304    
305                    return map;
306            }
307    
308            @Override
309            public Long getSize(String name) {
310                    Long size = _uploadServletRequest.getSize(_namespace.concat(name));
311    
312                    if (size == null) {
313                            size = _uploadServletRequest.getSize(name);
314                    }
315    
316                    if (size == null) {
317                            return Long.valueOf(0);
318                    }
319    
320                    return size;
321            }
322    
323            @Override
324            public Boolean isFormField(String name) {
325                    Boolean formField = _uploadServletRequest.isFormField(
326                            _namespace.concat(name));
327    
328                    if (formField == null) {
329                            formField = _uploadServletRequest.isFormField(name);
330                    }
331    
332                    if (formField == null) {
333                            return true;
334                    }
335                    else {
336                            return formField.booleanValue();
337                    }
338            }
339    
340            private final String _namespace;
341            private final PortletRequest _portletRequest;
342            private final UploadServletRequest _uploadServletRequest;
343    
344    }