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