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.repository.capabilities;
016    
017    import com.liferay.portal.NoSuchModelException;
018    import com.liferay.portal.kernel.dao.orm.QueryUtil;
019    import com.liferay.portal.kernel.exception.PortalException;
020    import com.liferay.portal.kernel.exception.SystemException;
021    import com.liferay.portal.kernel.repository.LocalRepository;
022    import com.liferay.portal.kernel.repository.capabilities.BulkOperationCapability;
023    import com.liferay.portal.kernel.repository.capabilities.ConfigurationCapability;
024    import com.liferay.portal.kernel.repository.capabilities.TemporaryFileEntriesCapability;
025    import com.liferay.portal.kernel.repository.model.BaseRepositoryModelOperation;
026    import com.liferay.portal.kernel.repository.model.FileEntry;
027    import com.liferay.portal.kernel.repository.model.Folder;
028    import com.liferay.portal.kernel.util.FileUtil;
029    import com.liferay.portal.kernel.util.GetterUtil;
030    import com.liferay.portal.kernel.util.StringPool;
031    import com.liferay.portal.kernel.util.StringUtil;
032    import com.liferay.portal.service.ServiceContext;
033    import com.liferay.portlet.documentlibrary.NoSuchFolderException;
034    import com.liferay.portlet.documentlibrary.model.DLFolderConstants;
035    
036    import java.io.File;
037    import java.io.IOException;
038    import java.io.InputStream;
039    
040    import java.util.Collections;
041    import java.util.Date;
042    import java.util.List;
043    import java.util.UUID;
044    
045    /**
046     * @author Iv??n Zaera
047     */
048    public class TemporaryFileEntriesCapabilityImpl
049            implements TemporaryFileEntriesCapability {
050    
051            public TemporaryFileEntriesCapabilityImpl(LocalRepository localRepository) {
052                    _localRepository = localRepository;
053            }
054    
055            @Override
056            public FileEntry addTemporaryFileEntry(
057                            UUID callerUuid, long userId, String folderPath, String fileName,
058                            String mimeType, InputStream inputStream)
059                    throws PortalException {
060    
061                    Folder folder = addTempFolder(userId, callerUuid, folderPath);
062    
063                    File file = null;
064    
065                    try {
066                            file = FileUtil.createTempFile(inputStream);
067    
068                            ServiceContext serviceContext = new ServiceContext();
069    
070                            serviceContext.setAddGroupPermissions(true);
071                            serviceContext.setAddGuestPermissions(true);
072    
073                            return _localRepository.addFileEntry(
074                                    userId, folder.getFolderId(), fileName, mimeType, fileName,
075                                    StringPool.BLANK, StringPool.BLANK, file, serviceContext);
076                    }
077                    catch (IOException ioe) {
078                            throw new SystemException("Unable to write temporary file", ioe);
079                    }
080                    finally {
081                            FileUtil.delete(file);
082                    }
083            }
084    
085            @Override
086            public void deleteExpiredTemporaryFileEntries() throws PortalException {
087                    BulkOperationCapability bulkOperationCapability =
088                            _localRepository.getCapability(BulkOperationCapability.class);
089    
090                    BulkOperationCapability.Filter<Date> bulkFilter =
091                            new BulkOperationCapability.Filter<>(
092                                    BulkOperationCapability.Field.CreateDate.class,
093                                    BulkOperationCapability.Operator.LT,
094                                    new Date(
095                                            System.currentTimeMillis() -
096                                                    getTemporaryFileEntriesTimeout()));
097    
098                    bulkOperationCapability.execute(
099                            bulkFilter,
100                            new DeleteExpiredTemporaryFilesRepositoryModelOperation());
101            }
102    
103            @Override
104            public void deleteTemporaryFileEntry(
105                            UUID callerUuid, String folderPath, String fileName)
106                    throws PortalException {
107    
108                    try {
109                            FileEntry fileEntry = getTemporaryFileEntries(
110                                    callerUuid, folderPath, fileName);
111    
112                            _localRepository.deleteFileEntry(fileEntry.getFileEntryId());
113                    }
114                    catch (NoSuchModelException nsme) {
115                    }
116            }
117    
118            @Override
119            public List<FileEntry> getTemporaryFileEntries(
120                            UUID callerUuid, String folderPath)
121                    throws PortalException {
122    
123                    try {
124                            Folder folder = getTempFolder(callerUuid, folderPath);
125    
126                            return _localRepository.getRepositoryFileEntries(
127                                    folder.getFolderId(), QueryUtil.ALL_POS, QueryUtil.ALL_POS,
128                                    null);
129                    }
130                    catch (NoSuchModelException nsme) {
131                            return Collections.emptyList();
132                    }
133            }
134    
135            @Override
136            public FileEntry getTemporaryFileEntries(
137                            UUID callerUuid, String folderPath, String fileName)
138                    throws PortalException {
139    
140                    Folder folder = getTempFolder(callerUuid, folderPath);
141    
142                    return _localRepository.getFileEntry(folder.getFolderId(), fileName);
143            }
144    
145            @Override
146            public long getTemporaryFileEntriesTimeout() {
147                    ConfigurationCapability configurationCapability =
148                            _localRepository.getCapability(ConfigurationCapability.class);
149    
150                    String temporaryFileEntriesTimeout =
151                            configurationCapability.getProperty(
152                                    getClass(), _PROPERTY_TEMPORARY_FILE_ENTRIES_TIMEOUT);
153    
154                    if (temporaryFileEntriesTimeout == null) {
155                            return _TEMPORARY_FILE_ENTRIES_TIMEOUT_DEFAULT;
156                    }
157    
158                    return GetterUtil.getLong(temporaryFileEntriesTimeout);
159            }
160    
161            @Override
162            public void setTemporaryFileEntriesTimeout(
163                    long temporaryFileEntriesTimeout) {
164    
165                    ConfigurationCapability configurationCapability =
166                            _localRepository.getCapability(ConfigurationCapability.class);
167    
168                    configurationCapability.setProperty(
169                            getClass(), _PROPERTY_TEMPORARY_FILE_ENTRIES_TIMEOUT,
170                            String.valueOf(temporaryFileEntriesTimeout));
171            }
172    
173            protected Folder addFolder(
174                            long userId, long parentFolderId, String folderName,
175                            ServiceContext serviceContext)
176                    throws PortalException {
177    
178                    try {
179                            return getFolder(parentFolderId, folderName);
180                    }
181                    catch (NoSuchFolderException nsfe) {
182                            return _localRepository.addFolder(
183                                    userId, parentFolderId, folderName, StringPool.BLANK,
184                                    serviceContext);
185                    }
186            }
187    
188            protected Folder addFolders(
189                            long userId, long folderId, String folderPath,
190                            ServiceContext serviceContext)
191                    throws PortalException {
192    
193                    Folder folder = null;
194    
195                    String[] folderNames = StringUtil.split(folderPath, StringPool.SLASH);
196    
197                    for (String folderName : folderNames) {
198                            folder = addFolder(userId, folderId, folderName, serviceContext);
199    
200                            folderId = folder.getFolderId();
201                    }
202    
203                    return folder;
204            }
205    
206            protected Folder addTempFolder(
207                            long userId, UUID callerUuid, String folderPath)
208                    throws PortalException {
209    
210                    ServiceContext serviceContext = new ServiceContext();
211    
212                    serviceContext.setAddGroupPermissions(true);
213                    serviceContext.setAddGuestPermissions(true);
214    
215                    Folder tempFolder = addFolder(
216                            userId, DLFolderConstants.DEFAULT_PARENT_FOLDER_ID,
217                            _FOLDER_NAME_TEMP, serviceContext);
218    
219                    Folder folder = addFolder(
220                            userId, tempFolder.getFolderId(), callerUuid.toString(),
221                            serviceContext);
222    
223                    return addFolders(
224                            userId, folder.getFolderId(), folderPath, serviceContext);
225            }
226    
227            protected Folder getDeepestFolder(long parentFolderId, String folderPath)
228                    throws PortalException {
229    
230                    Folder folder = null;
231    
232                    String[] folderNames = StringUtil.split(folderPath, StringPool.SLASH);
233    
234                    for (String folderName : folderNames) {
235                            folder = _localRepository.getFolder(parentFolderId, folderName);
236    
237                            parentFolderId = folder.getFolderId();
238                    }
239    
240                    return folder;
241            }
242    
243            protected Folder getFolder(long parentFolderId, String folderName)
244                    throws PortalException {
245    
246                    return _localRepository.getFolder(parentFolderId, folderName);
247            }
248    
249            protected Folder getTempFolder(UUID callerUuid, String folderPath)
250                    throws PortalException {
251    
252                    ServiceContext serviceContext = new ServiceContext();
253    
254                    serviceContext.setAddGroupPermissions(true);
255                    serviceContext.setAddGuestPermissions(true);
256    
257                    Folder tempFolder = getFolder(
258                            DLFolderConstants.DEFAULT_PARENT_FOLDER_ID, _FOLDER_NAME_TEMP);
259    
260                    Folder folder = getFolder(
261                            tempFolder.getFolderId(), callerUuid.toString());
262    
263                    return getDeepestFolder(folder.getFolderId(), folderPath);
264            }
265    
266            private static final String _FOLDER_NAME_TEMP = "temp";
267    
268            private static final String _PROPERTY_TEMPORARY_FILE_ENTRIES_TIMEOUT =
269                    "temporaryFilesTimeout";
270    
271            private static final long _TEMPORARY_FILE_ENTRIES_TIMEOUT_DEFAULT =
272                    12 * 60 * 60 * 1000;
273    
274            private final LocalRepository _localRepository;
275    
276            private class DeleteExpiredTemporaryFilesRepositoryModelOperation
277                    extends BaseRepositoryModelOperation {
278    
279                    @Override
280                    public void execute(FileEntry fileEntry) throws PortalException {
281                            _localRepository.deleteFileEntry(fileEntry.getFileEntryId());
282                    }
283    
284            }
285    
286    }