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