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 (Map.Entry<String, FileItem[]> entry :
203                                    multipartParameterMap.entrySet()) {
204    
205                            String name = entry.getKey();
206                            FileItem[] fileItems = entry.getValue();
207    
208                            if (name.startsWith(_namespace)) {
209                                    map.put(
210                                            name.substring(_namespace.length(), name.length()),
211                                            fileItems);
212                            }
213                            else {
214                                    map.put(name, fileItems);
215                            }
216                    }
217    
218                    return map;
219            }
220    
221            @Override
222            public String getParameter(String name) {
223                    String parameter = _uploadServletRequest.getParameter(
224                            _namespace.concat(name));
225    
226                    if (parameter == null) {
227                            parameter = _uploadServletRequest.getParameter(name);
228                    }
229    
230                    return parameter;
231            }
232    
233            @Override
234            public Map<String, String[]> getParameterMap() {
235                    Map<String, String[]> map = new HashMap<>();
236    
237                    Enumeration<String> enu = getParameterNames();
238    
239                    while (enu.hasMoreElements()) {
240                            String name = enu.nextElement();
241    
242                            map.put(name, getParameterValues(name));
243                    }
244    
245                    return map;
246            }
247    
248            @Override
249            public Enumeration<String> getParameterNames() {
250                    List<String> parameterNames = new ArrayList<>();
251    
252                    Enumeration<String> enu = _uploadServletRequest.getParameterNames();
253    
254                    while (enu.hasMoreElements()) {
255                            String name = enu.nextElement();
256    
257                            if (name.startsWith(_namespace)) {
258                                    parameterNames.add(name.substring(_namespace.length()));
259                            }
260                            else {
261                                    parameterNames.add(name);
262                            }
263                    }
264    
265                    return Collections.enumeration(parameterNames);
266            }
267    
268            @Override
269            public String[] getParameterValues(String name) {
270                    String[] parameterValues = _uploadServletRequest.getParameterValues(
271                            _namespace.concat(name));
272    
273                    if (parameterValues == null) {
274                            parameterValues = _uploadServletRequest.getParameterValues(name);
275                    }
276    
277                    return parameterValues;
278            }
279    
280            @Override
281            public PortletRequest getPortletRequest() {
282                    return _portletRequest;
283            }
284    
285            @Override
286            public Map<String, List<String>> getRegularParameterMap() {
287                    if (!(_uploadServletRequest instanceof UploadServletRequestImpl)) {
288                            return Collections.emptyMap();
289                    }
290    
291                    Map<String, List<String>> map = new HashMap<>();
292    
293                    UploadServletRequestImpl uploadServletRequestImpl =
294                            (UploadServletRequestImpl)_uploadServletRequest;
295    
296                    Map<String, List<String>> regularParameterMap =
297                            uploadServletRequestImpl.getRegularParameterMap();
298    
299                    for (Map.Entry<String, List<String>> entry :
300                                    regularParameterMap.entrySet()) {
301    
302                            String name = entry.getKey();
303                            List<String> parameters = entry.getValue();
304    
305                            if (name.startsWith(_namespace)) {
306                                    map.put(
307                                            name.substring(_namespace.length(), name.length()),
308                                            parameters);
309                            }
310                            else {
311                                    map.put(name, parameters);
312                            }
313                    }
314    
315                    return map;
316            }
317    
318            @Override
319            public Long getSize(String name) {
320                    Long size = _uploadServletRequest.getSize(_namespace.concat(name));
321    
322                    if (size == null) {
323                            size = _uploadServletRequest.getSize(name);
324                    }
325    
326                    if (size == null) {
327                            return Long.valueOf(0);
328                    }
329    
330                    return size;
331            }
332    
333            @Override
334            public Boolean isFormField(String name) {
335                    Boolean formField = _uploadServletRequest.isFormField(
336                            _namespace.concat(name));
337    
338                    if (formField == null) {
339                            formField = _uploadServletRequest.isFormField(name);
340                    }
341    
342                    if (formField == null) {
343                            return true;
344                    }
345                    else {
346                            return formField.booleanValue();
347                    }
348            }
349    
350            private final String _namespace;
351            private final PortletRequest _portletRequest;
352            private final UploadServletRequest _uploadServletRequest;
353    
354    }