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