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.kernel.util;
016    
017    import com.liferay.portal.kernel.security.pacl.permission.PortalFilePermission;
018    import com.liferay.portal.kernel.security.pacl.permission.PortalRuntimePermission;
019    
020    import java.io.File;
021    import java.io.FileInputStream;
022    import java.io.IOException;
023    import java.io.InputStream;
024    import java.io.Reader;
025    
026    import java.util.List;
027    import java.util.Properties;
028    
029    /**
030     * @author Brian Wing Shun Chan
031     * @author Alexander Chow
032     */
033    public class FileUtil {
034    
035            public static void copyDirectory(File source, File destination)
036                    throws IOException {
037    
038                    PortalFilePermission.checkCopy(_getPath(source), _getPath(destination));
039    
040                    getFile().copyDirectory(source, destination);
041            }
042    
043            public static void copyDirectory(
044                            String sourceDirName, String destinationDirName)
045                    throws IOException {
046    
047                    PortalFilePermission.checkCopy(sourceDirName, destinationDirName);
048    
049                    getFile().copyDirectory(sourceDirName, destinationDirName);
050            }
051    
052            public static void copyFile(File source, File destination)
053                    throws IOException {
054    
055                    PortalFilePermission.checkCopy(_getPath(source), _getPath(destination));
056    
057                    getFile().copyFile(source, destination);
058            }
059    
060            public static void copyFile(File source, File destination, boolean lazy)
061                    throws IOException {
062    
063                    PortalFilePermission.checkCopy(_getPath(source), _getPath(destination));
064    
065                    getFile().copyFile(source, destination, lazy);
066            }
067    
068            public static void copyFile(String source, String destination)
069                    throws IOException {
070    
071                    PortalFilePermission.checkCopy(source, destination);
072    
073                    getFile().copyFile(source, destination);
074            }
075    
076            public static void copyFile(String source, String destination, boolean lazy)
077                    throws IOException {
078    
079                    PortalFilePermission.checkCopy(source, destination);
080    
081                    getFile().copyFile(source, destination, lazy);
082            }
083    
084            public static File createTempFile() {
085                    PortalFilePermission.checkWrite(
086                            SystemProperties.get(SystemProperties.TMP_DIR));
087    
088                    return getFile().createTempFile();
089            }
090    
091            public static File createTempFile(byte[] bytes) throws IOException {
092                    PortalFilePermission.checkWrite(
093                            SystemProperties.get(SystemProperties.TMP_DIR));
094    
095                    return getFile().createTempFile(bytes);
096            }
097    
098            public static File createTempFile(InputStream is) throws IOException {
099                    PortalFilePermission.checkWrite(
100                            SystemProperties.get(SystemProperties.TMP_DIR));
101    
102                    return getFile().createTempFile(is);
103            }
104    
105            public static File createTempFile(String extension) {
106                    PortalFilePermission.checkWrite(
107                            SystemProperties.get(SystemProperties.TMP_DIR));
108    
109                    return getFile().createTempFile(extension);
110            }
111    
112            public static String createTempFileName() {
113                    PortalFilePermission.checkWrite(
114                            SystemProperties.get(SystemProperties.TMP_DIR));
115    
116                    return getFile().createTempFileName();
117            }
118    
119            public static String createTempFileName(String extension) {
120                    PortalFilePermission.checkWrite(
121                            SystemProperties.get(SystemProperties.TMP_DIR));
122    
123                    return getFile().createTempFileName(extension);
124            }
125    
126            public static File createTempFolder() {
127                    PortalFilePermission.checkWrite(
128                            SystemProperties.get(SystemProperties.TMP_DIR));
129    
130                    return getFile().createTempFolder();
131            }
132    
133            public static String decodeSafeFileName(String fileName) {
134                    return getFile().decodeSafeFileName(fileName);
135            }
136    
137            public static boolean delete(File file) {
138                    PortalFilePermission.checkDelete(_getPath(file));
139    
140                    return getFile().delete(file);
141            }
142    
143            public static boolean delete(String file) {
144                    PortalFilePermission.checkDelete(file);
145    
146                    return getFile().delete(file);
147            }
148    
149            public static void deltree(File directory) {
150                    PortalFilePermission.checkDelete(_getPath(directory));
151    
152                    getFile().deltree(directory);
153            }
154    
155            public static void deltree(String directory) {
156                    PortalFilePermission.checkDelete(directory);
157    
158                    getFile().deltree(directory);
159            }
160    
161            public static String encodeSafeFileName(String fileName) {
162                    return getFile().encodeSafeFileName(fileName);
163            }
164    
165            public static boolean exists(File file) {
166                    PortalFilePermission.checkRead(_getPath(file));
167    
168                    return getFile().exists(file);
169            }
170    
171            public static boolean exists(String fileName) {
172                    PortalFilePermission.checkRead(fileName);
173    
174                    return getFile().exists(fileName);
175            }
176    
177            /**
178             * Extract text from an input stream and file name.
179             *
180             * @param  is input stream of file
181             * @param  fileName full name or extension of file (e.g., "Test.doc",
182             *         ".doc")
183             * @return Extracted text if it is a supported format or an empty string if
184             *         it is an unsupported format
185             */
186            public static String extractText(InputStream is, String fileName) {
187                    return getFile().extractText(is, fileName);
188            }
189    
190            public static String[] find(
191                    String directory, String includes, String excludes) {
192    
193                    PortalFilePermission.checkRead(directory);
194    
195                    return getFile().find(directory, includes, excludes);
196            }
197    
198            public static String getAbsolutePath(File file) {
199                    return getFile().getAbsolutePath(file);
200            }
201    
202            public static byte[] getBytes(File file) throws IOException {
203                    PortalFilePermission.checkRead(_getPath(file));
204    
205                    return getFile().getBytes(file);
206            }
207    
208            public static byte[] getBytes(InputStream is) throws IOException {
209                    return getFile().getBytes(is);
210            }
211    
212            public static byte[] getBytes(InputStream is, int bufferSize)
213                    throws IOException {
214    
215                    return getFile().getBytes(is);
216            }
217    
218            public static byte[] getBytes(
219                            InputStream is, int bufferSize, boolean cleanUpStream)
220                    throws IOException {
221    
222                    return getFile().getBytes(is, bufferSize, cleanUpStream);
223            }
224    
225            public static String getExtension(String fileName) {
226                    return getFile().getExtension(fileName);
227            }
228    
229            public static com.liferay.portal.kernel.util.File getFile() {
230                    PortalRuntimePermission.checkGetBeanProperty(FileUtil.class);
231    
232                    return _file;
233            }
234    
235            public static String getPath(String fullFileName) {
236                    return getFile().getPath(fullFileName);
237            }
238    
239            public static String getShortFileName(String fullFileName) {
240                    return getFile().getShortFileName(fullFileName);
241            }
242    
243            public static boolean isAscii(File file) throws IOException {
244                    PortalFilePermission.checkRead(_getPath(file));
245    
246                    return getFile().isAscii(file);
247            }
248    
249            public static boolean isSameContent(File file, byte[] bytes, int length) {
250                    PortalFilePermission.checkRead(_getPath(file));
251    
252                    return getFile().isSameContent(file, bytes, length);
253            }
254    
255            public static boolean isSameContent(File file, String s) {
256                    PortalFilePermission.checkRead(_getPath(file));
257    
258                    return getFile().isSameContent(file, s);
259            }
260    
261            public static String[] listDirs(File file) {
262                    PortalFilePermission.checkRead(_getPath(file));
263    
264                    return getFile().listDirs(file);
265            }
266    
267            public static String[] listDirs(String fileName) {
268                    PortalFilePermission.checkRead(fileName);
269    
270                    return getFile().listDirs(fileName);
271            }
272    
273            public static String[] listFiles(File file) {
274                    PortalFilePermission.checkRead(_getPath(file));
275    
276                    return getFile().listFiles(file);
277            }
278    
279            public static String[] listFiles(String fileName) {
280                    PortalFilePermission.checkRead(fileName);
281    
282                    return getFile().listFiles(fileName);
283            }
284    
285            public static void mkdirs(String pathName) {
286                    PortalFilePermission.checkCopy(pathName, pathName);
287    
288                    getFile().mkdirs(pathName);
289            }
290    
291            public static boolean move(File source, File destination) {
292                    PortalFilePermission.checkMove(_getPath(source), _getPath(destination));
293    
294                    return getFile().move(source, destination);
295            }
296    
297            public static boolean move(
298                    String sourceFileName, String destinationFileName) {
299    
300                    PortalFilePermission.checkMove(sourceFileName, destinationFileName);
301    
302                    return getFile().move(sourceFileName, destinationFileName);
303            }
304    
305            public static String read(File file) throws IOException {
306                    PortalFilePermission.checkRead(_getPath(file));
307    
308                    return getFile().read(file);
309            }
310    
311            public static String read(File file, boolean raw) throws IOException {
312                    PortalFilePermission.checkRead(_getPath(file));
313    
314                    return getFile().read(file, raw);
315            }
316    
317            public static String read(String fileName) throws IOException {
318                    PortalFilePermission.checkRead(fileName);
319    
320                    return getFile().read(fileName);
321            }
322    
323            public static String replaceSeparator(String fileName) {
324                    return getFile().replaceSeparator(fileName);
325            }
326    
327            public static File[] sortFiles(File[] files) {
328                    return getFile().sortFiles(files);
329            }
330    
331            public static String stripExtension(String fileName) {
332                    return getFile().stripExtension(fileName);
333            }
334    
335            public static List<String> toList(Reader reader) {
336                    return getFile().toList(reader);
337            }
338    
339            public static List<String> toList(String fileName) {
340                    return getFile().toList(fileName);
341            }
342    
343            public static Properties toProperties(FileInputStream fis) {
344                    return getFile().toProperties(fis);
345            }
346    
347            public static Properties toProperties(String fileName) {
348                    PortalFilePermission.checkRead(fileName);
349    
350                    return getFile().toProperties(fileName);
351            }
352    
353            public static void touch(File file) throws IOException {
354                    PortalFilePermission.checkWrite(_getPath(file));
355    
356                    getFile().touch(file);
357            }
358    
359            public static void touch(String fileName) throws IOException {
360                    PortalFilePermission.checkWrite(fileName);
361    
362                    getFile().touch(fileName);
363            }
364    
365            public static void unzip(File source, File destination) {
366                    PortalFilePermission.checkCopy(_getPath(source), _getPath(destination));
367    
368                    getFile().unzip(source, destination);
369            }
370    
371            public static void write(File file, byte[] bytes) throws IOException {
372                    PortalFilePermission.checkWrite(_getPath(file));
373    
374                    getFile().write(file, bytes);
375            }
376    
377            public static void write(File file, byte[] bytes, int offset, int length)
378                    throws IOException {
379    
380                    PortalFilePermission.checkWrite(_getPath(file));
381    
382                    getFile().write(file, bytes, offset, length);
383            }
384    
385            public static void write(File file, InputStream is) throws IOException {
386                    PortalFilePermission.checkWrite(_getPath(file));
387    
388                    getFile().write(file, is);
389            }
390    
391            public static void write(File file, String s) throws IOException {
392                    PortalFilePermission.checkWrite(_getPath(file));
393    
394                    getFile().write(file, s);
395            }
396    
397            public static void write(File file, String s, boolean lazy)
398                    throws IOException {
399    
400                    PortalFilePermission.checkWrite(_getPath(file));
401    
402                    getFile().write(file, s, lazy);
403            }
404    
405            public static void write(File file, String s, boolean lazy, boolean append)
406                    throws IOException {
407    
408                    PortalFilePermission.checkWrite(_getPath(file));
409    
410                    getFile().write(file, s, lazy, append);
411            }
412    
413            public static void write(String fileName, byte[] bytes) throws IOException {
414                    PortalFilePermission.checkWrite(fileName);
415    
416                    getFile().write(fileName, bytes);
417            }
418    
419            public static void write(String fileName, InputStream is)
420                    throws IOException {
421    
422                    PortalFilePermission.checkWrite(fileName);
423    
424                    getFile().write(fileName, is);
425            }
426    
427            public static void write(String fileName, String s) throws IOException {
428                    PortalFilePermission.checkWrite(fileName);
429    
430                    getFile().write(fileName, s);
431            }
432    
433            public static void write(String fileName, String s, boolean lazy)
434                    throws IOException {
435    
436                    PortalFilePermission.checkWrite(fileName);
437    
438                    getFile().write(fileName, s, lazy);
439            }
440    
441            public static void write(
442                            String fileName, String s, boolean lazy, boolean append)
443                    throws IOException {
444    
445                    PortalFilePermission.checkWrite(fileName);
446    
447                    getFile().write(fileName, s, lazy, append);
448            }
449    
450            public static void write(String pathName, String fileName, String s)
451                    throws IOException {
452    
453                    PortalFilePermission.checkWrite(pathName);
454    
455                    getFile().write(pathName, fileName, s);
456            }
457    
458            public static void write(
459                            String pathName, String fileName, String s, boolean lazy)
460                    throws IOException {
461    
462                    PortalFilePermission.checkWrite(pathName);
463    
464                    getFile().write(pathName, fileName, s, lazy);
465            }
466    
467            public static void write(
468                            String pathName, String fileName, String s, boolean lazy,
469                            boolean append)
470                    throws IOException {
471    
472                    PortalFilePermission.checkWrite(pathName);
473    
474                    getFile().write(pathName, fileName, s, lazy, append);
475            }
476    
477            public void setFile(com.liferay.portal.kernel.util.File file) {
478                    PortalRuntimePermission.checkSetBeanProperty(getClass());
479    
480                    _file = file;
481            }
482    
483            private static String _getPath(File file) {
484                    if (file == null) {
485                            return null;
486                    }
487    
488                    return file.getPath();
489            }
490    
491            private static com.liferay.portal.kernel.util.File _file;
492    
493    }