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.portlet.documentlibrary.util;
016    
017    import com.liferay.portal.fabric.InputResource;
018    import com.liferay.portal.fabric.OutputResource;
019    import com.liferay.portal.kernel.image.GhostscriptUtil;
020    import com.liferay.portal.kernel.log.Log;
021    import com.liferay.portal.kernel.log.LogFactoryUtil;
022    import com.liferay.portal.kernel.messaging.DestinationNames;
023    import com.liferay.portal.kernel.process.ClassPathUtil;
024    import com.liferay.portal.kernel.process.ProcessCallable;
025    import com.liferay.portal.kernel.process.ProcessChannel;
026    import com.liferay.portal.kernel.process.ProcessException;
027    import com.liferay.portal.kernel.process.ProcessExecutorUtil;
028    import com.liferay.portal.kernel.repository.model.FileEntry;
029    import com.liferay.portal.kernel.repository.model.FileVersion;
030    import com.liferay.portal.kernel.util.ContentTypes;
031    import com.liferay.portal.kernel.util.FileUtil;
032    import com.liferay.portal.kernel.util.GetterUtil;
033    import com.liferay.portal.kernel.util.MimeTypesUtil;
034    import com.liferay.portal.kernel.util.PropsKeys;
035    import com.liferay.portal.kernel.util.ServerDetector;
036    import com.liferay.portal.kernel.util.StreamUtil;
037    import com.liferay.portal.kernel.util.StringPool;
038    import com.liferay.portal.kernel.util.SystemEnv;
039    import com.liferay.portal.kernel.util.Validator;
040    import com.liferay.portal.kernel.xml.Element;
041    import com.liferay.portal.log.Log4jLogFactoryImpl;
042    import com.liferay.portal.repository.liferayrepository.model.LiferayFileVersion;
043    import com.liferay.portal.util.PropsUtil;
044    import com.liferay.portal.util.PropsValues;
045    import com.liferay.portlet.documentlibrary.NoSuchFileEntryException;
046    import com.liferay.portlet.documentlibrary.model.DLProcessorConstants;
047    import com.liferay.portlet.documentlibrary.store.DLStoreUtil;
048    import com.liferay.portlet.exportimport.lar.PortletDataContext;
049    import com.liferay.util.log4j.Log4JUtil;
050    
051    import java.io.File;
052    import java.io.InputStream;
053    
054    import java.util.ArrayList;
055    import java.util.Arrays;
056    import java.util.List;
057    import java.util.Map;
058    import java.util.Properties;
059    import java.util.Set;
060    import java.util.Vector;
061    import java.util.concurrent.Future;
062    
063    import org.apache.commons.lang.time.StopWatch;
064    import org.apache.pdfbox.pdmodel.PDDocument;
065    
066    /**
067     * @author Alexander Chow
068     * @author Mika Koivisto
069     * @author Juan Gonz??lez
070     * @author Sergio Gonz??lez
071     * @author Ivica Cardic
072     */
073    public class PDFProcessorImpl
074            extends DLPreviewableProcessor implements PDFProcessor {
075    
076            @Override
077            public void afterPropertiesSet() throws Exception {
078                    FileUtil.mkdirs(PREVIEW_TMP_PATH);
079                    FileUtil.mkdirs(THUMBNAIL_TMP_PATH);
080            }
081    
082            @Override
083            public void generateImages(
084                            FileVersion sourceFileVersion, FileVersion destinationFileVersion)
085                    throws Exception {
086    
087                    _generateImages(sourceFileVersion, destinationFileVersion);
088            }
089    
090            @Override
091            public InputStream getPreviewAsStream(FileVersion fileVersion, int index)
092                    throws Exception {
093    
094                    return doGetPreviewAsStream(fileVersion, index, PREVIEW_TYPE);
095            }
096    
097            @Override
098            public int getPreviewFileCount(FileVersion fileVersion) {
099                    try {
100                            return doGetPreviewFileCount(fileVersion);
101                    }
102                    catch (Exception e) {
103                            _log.error(e, e);
104                    }
105    
106                    return 0;
107            }
108    
109            @Override
110            public long getPreviewFileSize(FileVersion fileVersion, int index)
111                    throws Exception {
112    
113                    return doGetPreviewFileSize(fileVersion, index);
114            }
115    
116            @Override
117            public InputStream getThumbnailAsStream(FileVersion fileVersion, int index)
118                    throws Exception {
119    
120                    return doGetThumbnailAsStream(fileVersion, index);
121            }
122    
123            @Override
124            public long getThumbnailFileSize(FileVersion fileVersion, int index)
125                    throws Exception {
126    
127                    return doGetThumbnailFileSize(fileVersion, index);
128            }
129    
130            @Override
131            public String getType() {
132                    return DLProcessorConstants.PDF_PROCESSOR;
133            }
134    
135            @Override
136            public boolean hasImages(FileVersion fileVersion) {
137                    boolean hasImages = false;
138    
139                    try {
140                            hasImages = _hasImages(fileVersion);
141    
142                            if (!hasImages && isSupported(fileVersion)) {
143                                    _queueGeneration(null, fileVersion);
144                            }
145                    }
146                    catch (Exception e) {
147                            _log.error(e, e);
148                    }
149    
150                    return hasImages;
151            }
152    
153            @Override
154            public boolean isDocumentSupported(FileVersion fileVersion) {
155                    return isSupported(fileVersion);
156            }
157    
158            @Override
159            public boolean isDocumentSupported(String mimeType) {
160                    return isSupported(mimeType);
161            }
162    
163            @Override
164            public boolean isSupported(String mimeType) {
165                    if (Validator.isNull(mimeType)) {
166                            return false;
167                    }
168    
169                    if (mimeType.equals(ContentTypes.APPLICATION_PDF) ||
170                            mimeType.equals(ContentTypes.APPLICATION_X_PDF)) {
171    
172                            return true;
173                    }
174    
175                    if (DocumentConversionUtil.isEnabled()) {
176                            Set<String> extensions = MimeTypesUtil.getExtensions(mimeType);
177    
178                            for (String extension : extensions) {
179                                    extension = extension.substring(1);
180    
181                                    String[] targetExtensions =
182                                            DocumentConversionUtil.getConversions(extension);
183    
184                                    if (Arrays.binarySearch(targetExtensions, "pdf") >= 0) {
185                                            return true;
186                                    }
187                            }
188                    }
189    
190                    return false;
191            }
192    
193            @Override
194            public void trigger(
195                    FileVersion sourceFileVersion, FileVersion destinationFileVersion) {
196    
197                    super.trigger(sourceFileVersion, destinationFileVersion);
198    
199                    _queueGeneration(sourceFileVersion, destinationFileVersion);
200            }
201    
202            @Override
203            protected void copyPreviews(
204                    FileVersion sourceFileVersion, FileVersion destinationFileVersion) {
205    
206                    if (!PropsValues.DL_FILE_ENTRY_PREVIEW_ENABLED) {
207                            return;
208                    }
209    
210                    try {
211                            if (hasPreview(sourceFileVersion) &&
212                                    !hasPreview(destinationFileVersion)) {
213    
214                                    int count = getPreviewFileCount(sourceFileVersion);
215    
216                                    for (int i = 0; i < count; i++) {
217                                            String previewFilePath = getPreviewFilePath(
218                                                    destinationFileVersion, i + 1);
219    
220                                            InputStream is = doGetPreviewAsStream(
221                                                    sourceFileVersion, i + 1, PREVIEW_TYPE);
222    
223                                            addFileToStore(
224                                                    destinationFileVersion.getCompanyId(), PREVIEW_PATH,
225                                                    previewFilePath, is);
226                                    }
227                            }
228                    }
229                    catch (Exception e) {
230                            _log.error(e, e);
231                    }
232            }
233    
234            @Override
235            protected void doExportGeneratedFiles(
236                            PortletDataContext portletDataContext, FileEntry fileEntry,
237                            Element fileEntryElement)
238                    throws Exception {
239    
240                    exportThumbnails(
241                            portletDataContext, fileEntry, fileEntryElement, "pdf");
242    
243                    exportPreviews(portletDataContext, fileEntry, fileEntryElement);
244            }
245    
246            @Override
247            protected void doImportGeneratedFiles(
248                            PortletDataContext portletDataContext, FileEntry fileEntry,
249                            FileEntry importedFileEntry, Element fileEntryElement)
250                    throws Exception {
251    
252                    importThumbnails(
253                            portletDataContext, fileEntry, importedFileEntry, fileEntryElement,
254                            "pdf");
255    
256                    importPreviews(
257                            portletDataContext, fileEntry, importedFileEntry, fileEntryElement);
258            }
259    
260            protected void exportPreviews(
261                            PortletDataContext portletDataContext, FileEntry fileEntry,
262                            Element fileEntryElement)
263                    throws Exception {
264    
265                    FileVersion fileVersion = fileEntry.getFileVersion();
266    
267                    if (!isSupported(fileVersion) || !_hasImages(fileVersion)) {
268                            return;
269                    }
270    
271                    if (!portletDataContext.isPerformDirectBinaryImport()) {
272                            int previewFileCount = getPreviewFileCount(fileVersion);
273    
274                            fileEntryElement.addAttribute(
275                                    "bin-path-pdf-preview-count", String.valueOf(previewFileCount));
276    
277                            for (int i = 0; i < previewFileCount; i++) {
278                                    exportPreview(
279                                            portletDataContext, fileEntry, fileEntryElement, "pdf",
280                                            PREVIEW_TYPE, i);
281                            }
282                    }
283            }
284    
285            @Override
286            protected List<Long> getFileVersionIds() {
287                    return _fileVersionIds;
288            }
289    
290            @Override
291            protected String getPreviewType(FileVersion fileVersion) {
292                    return PREVIEW_TYPE;
293            }
294    
295            @Override
296            protected String getThumbnailType(FileVersion fileVersion) {
297                    return THUMBNAIL_TYPE;
298            }
299    
300            protected boolean hasPreview(FileVersion fileVersion) throws Exception {
301                    return hasPreview(fileVersion, null);
302            }
303    
304            @Override
305            protected boolean hasPreview(FileVersion fileVersion, String type)
306                    throws Exception {
307    
308                    String previewFilePath = getPreviewFilePath(fileVersion, 1);
309    
310                    return DLStoreUtil.hasFile(
311                            fileVersion.getCompanyId(), REPOSITORY_ID, previewFilePath);
312            }
313    
314            protected void importPreviews(
315                            PortletDataContext portletDataContext, FileEntry fileEntry,
316                            FileEntry importedFileEntry, Element fileEntryElement)
317                    throws Exception {
318    
319                    int previewFileCount = GetterUtil.getInteger(
320                            fileEntryElement.attributeValue("bin-path-pdf-preview-count"));
321    
322                    for (int i = 0; i < previewFileCount; i++) {
323                            importPreview(
324                                    portletDataContext, fileEntry, importedFileEntry,
325                                    fileEntryElement, "pdf", PREVIEW_TYPE, i);
326                    }
327            }
328    
329            private void _generateImages(FileVersion fileVersion, File file)
330                    throws Exception {
331    
332                    if (GhostscriptUtil.isEnabled()) {
333                            if (!_ghostscriptInitialized) {
334                                    GhostscriptUtil.reset();
335    
336                                    _ghostscriptInitialized = true;
337                            }
338    
339                            _generateImagesGS(fileVersion, file);
340                    }
341                    else {
342                            _generateImagesPB(fileVersion, file);
343                    }
344            }
345    
346            private void _generateImages(
347                            FileVersion sourceFileVersion, FileVersion destinationFileVersion)
348                    throws Exception {
349    
350                    InputStream inputStream = null;
351    
352                    try {
353                            if (sourceFileVersion != null) {
354                                    copy(sourceFileVersion, destinationFileVersion);
355    
356                                    return;
357                            }
358    
359                            if (_hasImages(destinationFileVersion)) {
360                                    return;
361                            }
362    
363                            String extension = destinationFileVersion.getExtension();
364    
365                            if (extension.equals("pdf")) {
366                                    if (destinationFileVersion instanceof LiferayFileVersion) {
367                                            try {
368                                                    LiferayFileVersion liferayFileVersion =
369                                                            (LiferayFileVersion)destinationFileVersion;
370    
371                                                    File file = liferayFileVersion.getFile(false);
372    
373                                                    _generateImages(destinationFileVersion, file);
374    
375                                                    return;
376                                            }
377                                            catch (UnsupportedOperationException uoe) {
378                                            }
379                                    }
380    
381                                    inputStream = destinationFileVersion.getContentStream(false);
382    
383                                    _generateImages(destinationFileVersion, inputStream);
384                            }
385                            else if (DocumentConversionUtil.isEnabled()) {
386                                    inputStream = destinationFileVersion.getContentStream(false);
387    
388                                    String tempFileId = DLUtil.getTempFileId(
389                                            destinationFileVersion.getFileEntryId(),
390                                            destinationFileVersion.getVersion());
391    
392                                    if (Validator.equals(
393                                                    "PWC", destinationFileVersion.getVersion())) {
394    
395                                            File file = new File(
396                                                    DocumentConversionUtil.getFilePath(tempFileId, "pdf"));
397    
398                                            FileUtil.delete(file);
399                                    }
400    
401                                    File file = DocumentConversionUtil.convert(
402                                            tempFileId, inputStream, extension, "pdf");
403    
404                                    _generateImages(destinationFileVersion, file);
405                            }
406                    }
407                    catch (NoSuchFileEntryException nsfee) {
408                    }
409                    finally {
410                            StreamUtil.cleanUp(inputStream);
411    
412                            _fileVersionIds.remove(destinationFileVersion.getFileVersionId());
413                    }
414            }
415    
416            private void _generateImages(
417                            FileVersion fileVersion, InputStream inputStream)
418                    throws Exception {
419    
420                    if (GhostscriptUtil.isEnabled()) {
421                            _generateImagesGS(fileVersion, inputStream);
422                    }
423                    else {
424                            _generateImagesPB(fileVersion, inputStream);
425                    }
426            }
427    
428            private void _generateImagesGS(FileVersion fileVersion, File file)
429                    throws Exception {
430    
431                    if (_isGeneratePreview(fileVersion)) {
432                            StopWatch stopWatch = new StopWatch();
433    
434                            stopWatch.start();
435    
436                            _generateImagesGS(fileVersion, file, false);
437    
438                            if (_log.isInfoEnabled()) {
439                                    int previewFileCount = getPreviewFileCount(fileVersion);
440    
441                                    _log.info(
442                                            "Ghostscript generated " + previewFileCount +
443                                                    " preview pages for " + fileVersion.getTitle() +
444                                                            " in " + stopWatch.getTime() + " ms");
445                            }
446                    }
447    
448                    if (_isGenerateThumbnail(fileVersion)) {
449                            StopWatch stopWatch = new StopWatch();
450    
451                            stopWatch.start();
452    
453                            _generateImagesGS(fileVersion, file, true);
454    
455                            if (_log.isInfoEnabled()) {
456                                    _log.info(
457                                            "Ghostscript generated a thumbnail for " +
458                                                    fileVersion.getTitle() + " in " + stopWatch.getTime() +
459                                                            " ms");
460                            }
461                    }
462            }
463    
464            private void _generateImagesGS(
465                            FileVersion fileVersion, File file, boolean thumbnail)
466                    throws Exception {
467    
468                    // Generate images
469    
470                    String tempFileId = DLUtil.getTempFileId(
471                            fileVersion.getFileEntryId(), fileVersion.getVersion());
472    
473                    List<String> arguments = new ArrayList<>();
474    
475                    arguments.add("-sDEVICE=png16m");
476    
477                    if (thumbnail) {
478                            arguments.add(
479                                    "-sOutputFile=" + getThumbnailTempFilePath(tempFileId));
480                            arguments.add("-dFirstPage=1");
481                            arguments.add("-dLastPage=1");
482                    }
483                    else {
484                            arguments.add(
485                                    "-sOutputFile=" + getPreviewTempFilePath(tempFileId, -1));
486                    }
487    
488                    arguments.add("-dPDFFitPage");
489                    arguments.add("-dTextAlphaBits=4");
490                    arguments.add("-dGraphicsAlphaBits=4");
491                    arguments.add("-r" + PropsValues.DL_FILE_ENTRY_PREVIEW_DOCUMENT_DPI);
492    
493                    if (PropsValues.DL_FILE_ENTRY_PREVIEW_DOCUMENT_MAX_WIDTH != 0) {
494                            arguments.add(
495                                    "-dDEVICEWIDTH=" +
496                                            PropsValues.DL_FILE_ENTRY_PREVIEW_DOCUMENT_MAX_WIDTH);
497                    }
498    
499                    if (PropsValues.DL_FILE_ENTRY_PREVIEW_DOCUMENT_MAX_HEIGHT != 0) {
500                            arguments.add(
501                                    "-dDEVICEHEIGHT=" +
502                                            PropsValues.DL_FILE_ENTRY_PREVIEW_DOCUMENT_MAX_HEIGHT);
503                    }
504    
505                    arguments.add(file.getPath());
506    
507                    Future<?> future = GhostscriptUtil.execute(arguments);
508    
509                    String processIdentity = String.valueOf(fileVersion.getFileVersionId());
510    
511                    futures.put(processIdentity, future);
512    
513                    future.get();
514    
515                    // Store images
516    
517                    if (thumbnail) {
518                            File thumbnailTempFile = getThumbnailTempFile(tempFileId);
519    
520                            try {
521                                    storeThumbnailImages(fileVersion, thumbnailTempFile);
522                            }
523                            finally {
524                                    FileUtil.delete(thumbnailTempFile);
525                            }
526                    }
527                    else {
528                            int total = getPreviewTempFileCount(fileVersion);
529    
530                            for (int i = 0; i < total; i++) {
531                                    File previewTempFile = getPreviewTempFile(tempFileId, i + 2);
532    
533                                    try {
534                                            addFileToStore(
535                                                    fileVersion.getCompanyId(), PREVIEW_PATH,
536                                                    getPreviewFilePath(fileVersion, i + 1),
537                                                    previewTempFile);
538                                    }
539                                    finally {
540                                            FileUtil.delete(previewTempFile);
541                                    }
542                            }
543                    }
544            }
545    
546            private void _generateImagesGS(
547                            FileVersion fileVersion, InputStream inputStream)
548                    throws Exception {
549    
550                    File file = null;
551    
552                    try {
553                            file = FileUtil.createTempFile(inputStream);
554    
555                            _generateImagesGS(fileVersion, file);
556                    }
557                    finally {
558                            FileUtil.delete(file);
559                    }
560            }
561    
562            private void _generateImagesPB(FileVersion fileVersion, File file)
563                    throws Exception {
564    
565                    String tempFileId = DLUtil.getTempFileId(
566                            fileVersion.getFileEntryId(), fileVersion.getVersion());
567    
568                    File thumbnailFile = getThumbnailTempFile(tempFileId);
569    
570                    int previewFilesCount = 0;
571    
572                    try (PDDocument pdDocument = PDDocument.load(file)) {
573                            previewFilesCount = pdDocument.getNumberOfPages();
574                    }
575    
576                    File[] previewFiles = new File[previewFilesCount];
577    
578                    for (int i = 0; i < previewFilesCount; i++) {
579                            previewFiles[i] = getPreviewTempFile(tempFileId, i);
580                    }
581    
582                    boolean generatePreview = _isGeneratePreview(fileVersion);
583                    boolean generateThumbnail = _isGenerateThumbnail(fileVersion);
584    
585                    if (PropsValues.DL_FILE_ENTRY_PREVIEW_FORK_PROCESS_ENABLED) {
586                            ProcessCallable<String> processCallable =
587                                    new LiferayPDFBoxProcessCallable(
588                                            ServerDetector.getServerId(),
589                                            PropsUtil.get(PropsKeys.LIFERAY_HOME),
590                                            Log4JUtil.getCustomLogSettings(), file, thumbnailFile,
591                                            previewFiles, getThumbnailType(fileVersion),
592                                            getPreviewType(fileVersion),
593                                            PropsValues.DL_FILE_ENTRY_PREVIEW_DOCUMENT_DPI,
594                                            PropsValues.DL_FILE_ENTRY_PREVIEW_DOCUMENT_MAX_HEIGHT,
595                                            PropsValues.DL_FILE_ENTRY_PREVIEW_DOCUMENT_MAX_WIDTH,
596                                            generatePreview, generateThumbnail);
597    
598                            ProcessChannel<String> processChannel = ProcessExecutorUtil.execute(
599                                    ClassPathUtil.getPortalProcessConfig(), processCallable);
600    
601                            Future<String> future = processChannel.getProcessNoticeableFuture();
602    
603                            String processIdentity = String.valueOf(
604                                    fileVersion.getFileVersionId());
605    
606                            futures.put(processIdentity, future);
607    
608                            future.get();
609                    }
610                    else {
611                            LiferayPDFBoxConverter liferayConverter =
612                                    new LiferayPDFBoxConverter(
613                                            file, thumbnailFile, previewFiles,
614                                            getPreviewType(fileVersion), getThumbnailType(fileVersion),
615                                            PropsValues.DL_FILE_ENTRY_PREVIEW_DOCUMENT_DPI,
616                                            PropsValues.DL_FILE_ENTRY_PREVIEW_DOCUMENT_MAX_HEIGHT,
617                                            PropsValues.DL_FILE_ENTRY_PREVIEW_DOCUMENT_MAX_WIDTH,
618                                            generatePreview, generateThumbnail);
619    
620                            liferayConverter.generateImagesPB();
621                    }
622    
623                    if (generateThumbnail) {
624                            try {
625                                    storeThumbnailImages(fileVersion, thumbnailFile);
626                            }
627                            finally {
628                                    FileUtil.delete(thumbnailFile);
629                            }
630    
631                            if (_log.isInfoEnabled()) {
632                                    _log.info(
633                                            "PDFBox generated a thumbnail for " +
634                                                    fileVersion.getFileVersionId());
635                            }
636                    }
637    
638                    if (generatePreview) {
639                            int index = 0;
640    
641                            for (File previewFile : previewFiles) {
642                                    try {
643                                            addFileToStore(
644                                                    fileVersion.getCompanyId(), PREVIEW_PATH,
645                                                    getPreviewFilePath(fileVersion, index + 1),
646                                                    previewFile);
647                                    }
648                                    finally {
649                                            FileUtil.delete(previewFile);
650                                    }
651    
652                                    index++;
653                            }
654    
655                            if (_log.isInfoEnabled()) {
656                                    _log.info(
657                                            "PDFBox generated " +
658                                                    getPreviewFileCount(fileVersion) +
659                                                            " preview pages for " +
660                                                                    fileVersion.getFileVersionId());
661                            }
662                    }
663            }
664    
665            private void _generateImagesPB(
666                            FileVersion fileVersion, InputStream inputStream)
667                    throws Exception {
668    
669                    File file = null;
670    
671                    try {
672                            file = FileUtil.createTempFile(inputStream);
673    
674                            _generateImagesPB(fileVersion, file);
675                    }
676                    finally {
677                            FileUtil.delete(file);
678                    }
679            }
680    
681            private boolean _hasImages(FileVersion fileVersion) throws Exception {
682                    if (PropsValues.DL_FILE_ENTRY_PREVIEW_ENABLED) {
683                            if (!hasPreview(fileVersion)) {
684                                    return false;
685                            }
686                    }
687    
688                    return hasThumbnails(fileVersion);
689            }
690    
691            private boolean _isGeneratePreview(FileVersion fileVersion)
692                    throws Exception {
693    
694                    if (PropsValues.DL_FILE_ENTRY_PREVIEW_ENABLED &&
695                            !hasPreview(fileVersion)) {
696    
697                            return true;
698                    }
699                    else {
700                            return false;
701                    }
702            }
703    
704            private boolean _isGenerateThumbnail(FileVersion fileVersion)
705                    throws Exception {
706    
707                    if (PropsValues.DL_FILE_ENTRY_THUMBNAIL_ENABLED &&
708                            !hasThumbnail(fileVersion, THUMBNAIL_INDEX_DEFAULT)) {
709    
710                            return true;
711                    }
712                    else {
713                            return false;
714                    }
715            }
716    
717            private void _queueGeneration(
718                    FileVersion sourceFileVersion, FileVersion destinationFileVersion) {
719    
720                    if (_fileVersionIds.contains(
721                                    destinationFileVersion.getFileVersionId())) {
722    
723                            return;
724                    }
725    
726                    boolean generateImages = false;
727    
728                    String extension = destinationFileVersion.getExtension();
729    
730                    if (extension.equals("pdf")) {
731                            generateImages = true;
732                    }
733                    else if (DocumentConversionUtil.isEnabled()) {
734                            String[] conversions = DocumentConversionUtil.getConversions(
735                                    extension);
736    
737                            for (String conversion : conversions) {
738                                    if (conversion.equals("pdf")) {
739                                            generateImages = true;
740    
741                                            break;
742                                    }
743                            }
744                    }
745    
746                    if (generateImages) {
747                            _fileVersionIds.add(destinationFileVersion.getFileVersionId());
748    
749                            sendGenerationMessage(
750                                    DestinationNames.DOCUMENT_LIBRARY_PDF_PROCESSOR,
751                                    sourceFileVersion, destinationFileVersion);
752                    }
753            }
754    
755            private static final Log _log = LogFactoryUtil.getLog(
756                    PDFProcessorImpl.class);
757    
758            private final List<Long> _fileVersionIds = new Vector<>();
759            private boolean _ghostscriptInitialized;
760    
761            private static class LiferayPDFBoxProcessCallable
762                    implements ProcessCallable<String> {
763    
764                    public LiferayPDFBoxProcessCallable(
765                            String serverId, String liferayHome,
766                            Map<String, String> customLogSettings, File inputFile,
767                            File thumbnailFile, File[] previewFiles, String extension,
768                            String thumbnailExtension, int dpi, int height, int width,
769                            boolean generatePreview, boolean generateThumbnail) {
770    
771                            _serverId = serverId;
772                            _liferayHome = liferayHome;
773                            _customLogSettings = customLogSettings;
774                            _inputFile = inputFile;
775                            _thumbnailFile = thumbnailFile;
776                            _previewFiles = previewFiles;
777                            _extension = extension;
778                            _thumbnailExtension = thumbnailExtension;
779                            _dpi = dpi;
780                            _height = height;
781                            _width = width;
782                            _generatePreview = generatePreview;
783                            _generateThumbnail = generateThumbnail;
784                    }
785    
786                    @Override
787                    public String call() throws ProcessException {
788                            Properties systemProperties = System.getProperties();
789    
790                            SystemEnv.setProperties(systemProperties);
791    
792                            Class<?> clazz = getClass();
793    
794                            ClassLoader classLoader = clazz.getClassLoader();
795    
796                            Log4JUtil.initLog4J(
797                                    _serverId, _liferayHome, classLoader, new Log4jLogFactoryImpl(),
798                                    _customLogSettings);
799    
800                            try {
801                                    LiferayPDFBoxConverter liferayConverter =
802                                            new LiferayPDFBoxConverter(
803                                                    _inputFile, _thumbnailFile, _previewFiles, _extension,
804                                                    _thumbnailExtension, _dpi, _height, _width,
805                                                    _generatePreview, _generateThumbnail);
806    
807                                    liferayConverter.generateImagesPB();
808                            }
809                            catch (Exception e) {
810                                    throw new ProcessException(e);
811                            }
812    
813                            return StringPool.BLANK;
814                    }
815    
816                    private static final long serialVersionUID = 1L;
817    
818                    private final Map<String, String> _customLogSettings;
819                    private final int _dpi;
820                    private final String _extension;
821                    private final boolean _generatePreview;
822                    private final boolean _generateThumbnail;
823                    private final int _height;
824    
825                    @InputResource
826                    private final File _inputFile;
827    
828                    private final String _liferayHome;
829    
830                    @OutputResource
831                    private final File[] _previewFiles;
832    
833                    private final String _serverId;
834                    private final String _thumbnailExtension;
835    
836                    @OutputResource
837                    private final File _thumbnailFile;
838    
839                    private final int _width;
840    
841            }
842    
843    }