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.kernel.exception.PortalException;
018    import com.liferay.portal.kernel.repository.LocalRepository;
019    import com.liferay.portal.kernel.repository.capabilities.CapabilityProvider;
020    import com.liferay.portal.kernel.repository.event.RepositoryEventTrigger;
021    import com.liferay.portal.kernel.repository.event.RepositoryEventType;
022    import com.liferay.portal.kernel.repository.model.FileEntry;
023    import com.liferay.portal.kernel.repository.model.FileShortcut;
024    import com.liferay.portal.kernel.repository.model.FileVersion;
025    import com.liferay.portal.kernel.repository.model.Folder;
026    import com.liferay.portal.kernel.repository.model.RepositoryEntry;
027    import com.liferay.portal.kernel.util.OrderByComparator;
028    import com.liferay.portal.service.ServiceContext;
029    
030    import java.io.File;
031    import java.io.InputStream;
032    
033    import java.util.List;
034    
035    /**
036     * @author Adolfo P??rez
037     */
038    public class CapabilityLocalRepository
039            extends BaseCapabilityRepository<LocalRepository>
040            implements LocalRepository {
041    
042            public CapabilityLocalRepository(
043                    LocalRepository localRepository, CapabilityProvider capabilityProvider,
044                    RepositoryEventTrigger repositoryEventTrigger) {
045    
046                    super(localRepository, capabilityProvider);
047    
048                    _repositoryEventTrigger = repositoryEventTrigger;
049            }
050    
051            @Override
052            public FileEntry addFileEntry(
053                            long userId, long folderId, String sourceFileName, String mimeType,
054                            String title, String description, String changeLog, File file,
055                            ServiceContext serviceContext)
056                    throws PortalException {
057    
058                    LocalRepository localRepository = getRepository();
059    
060                    FileEntry fileEntry = localRepository.addFileEntry(
061                            userId, folderId, sourceFileName, mimeType, title, description,
062                            changeLog, file, serviceContext);
063    
064                    _repositoryEventTrigger.trigger(
065                            RepositoryEventType.Add.class, FileEntry.class, fileEntry);
066    
067                    return fileEntry;
068            }
069    
070            @Override
071            public FileEntry addFileEntry(
072                            long userId, long folderId, String sourceFileName, String mimeType,
073                            String title, String description, String changeLog, InputStream is,
074                            long size, ServiceContext serviceContext)
075                    throws PortalException {
076    
077                    LocalRepository localRepository = getRepository();
078    
079                    FileEntry fileEntry = localRepository.addFileEntry(
080                            userId, folderId, sourceFileName, mimeType, title, description,
081                            changeLog, is, size, serviceContext);
082    
083                    _repositoryEventTrigger.trigger(
084                            RepositoryEventType.Add.class, FileEntry.class, fileEntry);
085    
086                    return fileEntry;
087            }
088    
089            @Override
090            public FileShortcut addFileShortcut(
091                            long userId, long folderId, long toFileEntryId,
092                            ServiceContext serviceContext)
093                    throws PortalException {
094    
095                    LocalRepository localRepository = getRepository();
096    
097                    FileShortcut fileShortcut = localRepository.addFileShortcut(
098                            userId, folderId, toFileEntryId, serviceContext);
099    
100                    _repositoryEventTrigger.trigger(
101                            RepositoryEventType.Add.class, FileShortcut.class, fileShortcut);
102    
103                    return fileShortcut;
104            }
105    
106            @Override
107            public Folder addFolder(
108                            long userId, long parentFolderId, String name, String description,
109                            ServiceContext serviceContext)
110                    throws PortalException {
111    
112                    LocalRepository localRepository = getRepository();
113    
114                    Folder folder = localRepository.addFolder(
115                            userId, parentFolderId, name, description, serviceContext);
116    
117                    _repositoryEventTrigger.trigger(
118                            RepositoryEventType.Add.class, Folder.class, folder);
119    
120                    return folder;
121            }
122    
123            @Override
124            public void checkInFileEntry(
125                            long userId, long fileEntryId, boolean major, String changeLog,
126                            ServiceContext serviceContext)
127                    throws PortalException {
128    
129                    LocalRepository localRepository = getRepository();
130    
131                    localRepository.checkInFileEntry(
132                            userId, fileEntryId, major, changeLog, serviceContext);
133    
134                    FileEntry fileEntry = localRepository.getFileEntry(fileEntryId);
135    
136                    _repositoryEventTrigger.trigger(
137                            RepositoryEventType.Update.class, FileEntry.class, fileEntry);
138            }
139    
140            @Override
141            public void checkInFileEntry(
142                            long userId, long fileEntryId, String lockUuid,
143                            ServiceContext serviceContext)
144                    throws PortalException {
145    
146                    LocalRepository localRepository = getRepository();
147    
148                    localRepository.checkInFileEntry(
149                            userId, fileEntryId, lockUuid, serviceContext);
150    
151                    FileEntry fileEntry = localRepository.getFileEntry(fileEntryId);
152    
153                    _repositoryEventTrigger.trigger(
154                            RepositoryEventType.Update.class, FileEntry.class, fileEntry);
155            }
156    
157            @Override
158            public FileEntry copyFileEntry(
159                            long userId, long groupId, long fileEntryId, long destFolderId,
160                            ServiceContext serviceContext)
161                    throws PortalException {
162    
163                    LocalRepository localRepository = getRepository();
164    
165                    FileEntry fileEntry = localRepository.copyFileEntry(
166                            userId, groupId, fileEntryId, destFolderId, serviceContext);
167    
168                    _repositoryEventTrigger.trigger(
169                            RepositoryEventType.Add.class, FileEntry.class, fileEntry);
170    
171                    return fileEntry;
172            }
173    
174            @Override
175            public void deleteAll() throws PortalException {
176                    LocalRepository localRepository = getRepository();
177    
178                    _repositoryEventTrigger.trigger(
179                            RepositoryEventType.Delete.class, LocalRepository.class,
180                            localRepository);
181    
182                    localRepository.deleteAll();
183            }
184    
185            @Override
186            public void deleteFileEntry(long fileEntryId) throws PortalException {
187                    LocalRepository localRepository = getRepository();
188    
189                    FileEntry fileEntry = localRepository.getFileEntry(fileEntryId);
190    
191                    _repositoryEventTrigger.trigger(
192                            RepositoryEventType.Delete.class, FileEntry.class, fileEntry);
193    
194                    localRepository.deleteFileEntry(fileEntryId);
195            }
196    
197            @Override
198            public void deleteFileShortcut(long fileShortcutId) throws PortalException {
199                    LocalRepository localRepository = getRepository();
200    
201                    FileShortcut fileShortcut = localRepository.getFileShortcut(
202                            fileShortcutId);
203    
204                    _repositoryEventTrigger.trigger(
205                            RepositoryEventType.Delete.class, FileShortcut.class, fileShortcut);
206    
207                    localRepository.deleteFileShortcut(fileShortcutId);
208            }
209    
210            @Override
211            public void deleteFileShortcuts(long toFileEntryId) throws PortalException {
212                    LocalRepository localRepository = getRepository();
213    
214                    FileEntry fileEntry = localRepository.getFileEntry(toFileEntryId);
215    
216                    List<FileShortcut> fileShortcuts = fileEntry.getFileShortcuts();
217    
218                    for (FileShortcut fileShortcut : fileShortcuts) {
219                            _repositoryEventTrigger.trigger(
220                                    RepositoryEventType.Delete.class, FileShortcut.class,
221                                    fileShortcut);
222                    }
223    
224                    localRepository.deleteFileShortcuts(toFileEntryId);
225            }
226    
227            @Override
228            public void deleteFolder(long folderId) throws PortalException {
229                    LocalRepository localRepository = getRepository();
230    
231                    Folder folder = localRepository.getFolder(folderId);
232    
233                    _repositoryEventTrigger.trigger(
234                            RepositoryEventType.Delete.class, Folder.class, folder);
235    
236                    localRepository.deleteFolder(folderId);
237            }
238    
239            @Override
240            public List<FileEntry> getFileEntries(
241                            long folderId, int status, int start, int end,
242                            OrderByComparator<FileEntry> obc)
243                    throws PortalException {
244    
245                    return getRepository().getFileEntries(
246                            folderId, status, start, end, obc);
247            }
248    
249            @Override
250            public List<FileEntry> getFileEntries(
251                            long folderId, int start, int end, OrderByComparator<FileEntry> obc)
252                    throws PortalException {
253    
254                    return getRepository().getFileEntries(folderId, start, end, obc);
255            }
256    
257            @Override
258            public List<RepositoryEntry> getFileEntriesAndFileShortcuts(
259                            long folderId, int status, int start, int end)
260                    throws PortalException {
261    
262                    return getRepository().getFileEntriesAndFileShortcuts(
263                            folderId, status, start, end);
264            }
265    
266            @Override
267            public int getFileEntriesAndFileShortcutsCount(long folderId, int status)
268                    throws PortalException {
269    
270                    return getRepository().getFileEntriesAndFileShortcutsCount(
271                            folderId, status);
272            }
273    
274            @Override
275            public int getFileEntriesCount(long folderId) throws PortalException {
276                    return getRepository().getFileEntriesCount(folderId);
277            }
278    
279            @Override
280            public int getFileEntriesCount(long folderId, int status)
281                    throws PortalException {
282    
283                    return getRepository().getFileEntriesCount(folderId, status);
284            }
285    
286            @Override
287            public FileEntry getFileEntry(long fileEntryId) throws PortalException {
288                    return getRepository().getFileEntry(fileEntryId);
289            }
290    
291            @Override
292            public FileEntry getFileEntry(long folderId, String title)
293                    throws PortalException {
294    
295                    return getRepository().getFileEntry(folderId, title);
296            }
297    
298            @Override
299            public FileEntry getFileEntryByUuid(String uuid) throws PortalException {
300                    return getRepository().getFileEntryByUuid(uuid);
301            }
302    
303            @Override
304            public FileShortcut getFileShortcut(long fileShortcutId)
305                    throws PortalException {
306    
307                    return getRepository().getFileShortcut(fileShortcutId);
308            }
309    
310            @Override
311            public FileVersion getFileVersion(long fileVersionId)
312                    throws PortalException {
313    
314                    return getRepository().getFileVersion(fileVersionId);
315            }
316    
317            @Override
318            public Folder getFolder(long folderId) throws PortalException {
319                    return getRepository().getFolder(folderId);
320            }
321    
322            @Override
323            public Folder getFolder(long parentFolderId, String name)
324                    throws PortalException {
325    
326                    return getRepository().getFolder(parentFolderId, name);
327            }
328    
329            @Override
330            public List<Folder> getFolders(
331                            long parentFolderId, boolean includeMountFolders, int start,
332                            int end, OrderByComparator<Folder> obc)
333                    throws PortalException {
334    
335                    return getRepository().getFolders(
336                            parentFolderId, includeMountFolders, start, end, obc);
337            }
338    
339            @Override
340            public List<Folder> getFolders(
341                            long parentFolderId, int status, boolean includeMountFolders,
342                            int start, int end, OrderByComparator<Folder> obc)
343                    throws PortalException {
344    
345                    return getRepository().getFolders(
346                            parentFolderId, status, includeMountFolders, start, end, obc);
347            }
348    
349            @Override
350            public int getFoldersCount(long parentFolderId, boolean includeMountfolders)
351                    throws PortalException {
352    
353                    return getRepository().getFoldersCount(
354                            parentFolderId, includeMountfolders);
355            }
356    
357            @Override
358            public int getFoldersCount(
359                            long parentFolderId, int status, boolean includeMountfolders)
360                    throws PortalException {
361    
362                    return getRepository().getFoldersCount(
363                            parentFolderId, status, includeMountfolders);
364            }
365    
366            @Override
367            public List<FileEntry> getRepositoryFileEntries(
368                            long userId, long rootFolderId, int start, int end,
369                            OrderByComparator<FileEntry> obc)
370                    throws PortalException {
371    
372                    return getRepository().getRepositoryFileEntries(
373                            userId, rootFolderId, start, end, obc);
374            }
375    
376            @Override
377            public long getRepositoryId() {
378                    return getRepository().getRepositoryId();
379            }
380    
381            @Override
382            public FileEntry moveFileEntry(
383                            long userId, long fileEntryId, long newFolderId,
384                            ServiceContext serviceContext)
385                    throws PortalException {
386    
387                    LocalRepository localRepository = getRepository();
388    
389                    FileEntry fileEntry = localRepository.moveFileEntry(
390                            userId, fileEntryId, newFolderId, serviceContext);
391    
392                    _repositoryEventTrigger.trigger(
393                            RepositoryEventType.Move.class, FileEntry.class, fileEntry);
394    
395                    return fileEntry;
396            }
397    
398            @Override
399            public Folder moveFolder(
400                            long userId, long folderId, long parentFolderId,
401                            ServiceContext serviceContext)
402                    throws PortalException {
403    
404                    LocalRepository localRepository = getRepository();
405    
406                    Folder folder = localRepository.moveFolder(
407                            userId, folderId, parentFolderId, serviceContext);
408    
409                    _repositoryEventTrigger.trigger(
410                            RepositoryEventType.Move.class, Folder.class, folder);
411    
412                    return folder;
413            }
414    
415            @Override
416            public void revertFileEntry(
417                            long userId, long fileEntryId, String version,
418                            ServiceContext serviceContext)
419                    throws PortalException {
420    
421                    LocalRepository localRepository = getRepository();
422    
423                    localRepository.revertFileEntry(
424                            userId, fileEntryId, version, serviceContext);
425    
426                    FileEntry fileEntry = getFileEntry(fileEntryId);
427    
428                    _repositoryEventTrigger.trigger(
429                            RepositoryEventType.Update.class, FileEntry.class, fileEntry);
430            }
431    
432            /**
433             * @deprecated As of 7.0.0, with no direct replacement
434             */
435            @Deprecated
436            @Override
437            public void updateAsset(
438                            long userId, FileEntry fileEntry, FileVersion fileVersion,
439                            long[] assetCategoryIds, String[] assetTagNames,
440                            long[] assetLinkEntryIds)
441                    throws PortalException {
442    
443                    getRepository().updateAsset(
444                            userId, fileEntry, fileVersion, assetCategoryIds, assetTagNames,
445                            assetLinkEntryIds);
446            }
447    
448            @Override
449            public FileEntry updateFileEntry(
450                            long userId, long fileEntryId, String sourceFileName,
451                            String mimeType, String title, String description, String changeLog,
452                            boolean majorVersion, File file, ServiceContext serviceContext)
453                    throws PortalException {
454    
455                    LocalRepository localRepository = getRepository();
456    
457                    FileEntry fileEntry = localRepository.updateFileEntry(
458                            userId, fileEntryId, sourceFileName, mimeType, title, description,
459                            changeLog, majorVersion, file, serviceContext);
460    
461                    _repositoryEventTrigger.trigger(
462                            RepositoryEventType.Update.class, FileEntry.class, fileEntry);
463    
464                    return fileEntry;
465            }
466    
467            @Override
468            public FileEntry updateFileEntry(
469                            long userId, long fileEntryId, String sourceFileName,
470                            String mimeType, String title, String description, String changeLog,
471                            boolean majorVersion, InputStream is, long size,
472                            ServiceContext serviceContext)
473                    throws PortalException {
474    
475                    LocalRepository localRepository = getRepository();
476    
477                    FileEntry fileEntry = localRepository.updateFileEntry(
478                            userId, fileEntryId, sourceFileName, mimeType, title, description,
479                            changeLog, majorVersion, is, size, serviceContext);
480    
481                    _repositoryEventTrigger.trigger(
482                            RepositoryEventType.Update.class, FileEntry.class, fileEntry);
483    
484                    return fileEntry;
485            }
486    
487            @Override
488            public FileShortcut updateFileShortcut(
489                            long userId, long fileShortcutId, long folderId, long toFileEntryId,
490                            ServiceContext serviceContext)
491                    throws PortalException {
492    
493                    LocalRepository localRepository = getRepository();
494    
495                    FileShortcut fileShortcut = localRepository.updateFileShortcut(
496                            userId, fileShortcutId, folderId, toFileEntryId, serviceContext);
497    
498                    _repositoryEventTrigger.trigger(
499                            RepositoryEventType.Update.class, FileShortcut.class, fileShortcut);
500    
501                    return fileShortcut;
502            }
503    
504            @Override
505            public void updateFileShortcuts(
506                            long oldToFileEntryId, long newToFileEntryId)
507                    throws PortalException {
508    
509                    LocalRepository localRepository = getRepository();
510    
511                    FileEntry fileEntry = localRepository.getFileEntry(oldToFileEntryId);
512    
513                    fileEntry.getFileShortcuts();
514    
515                    localRepository.updateFileShortcuts(oldToFileEntryId, newToFileEntryId);
516            }
517    
518            @Override
519            public Folder updateFolder(
520                            long folderId, long parentFolderId, String name, String description,
521                            ServiceContext serviceContext)
522                    throws PortalException {
523    
524                    LocalRepository localRepository = getRepository();
525    
526                    Folder folder = localRepository.updateFolder(
527                            folderId, parentFolderId, name, description, serviceContext);
528    
529                    _repositoryEventTrigger.trigger(
530                            RepositoryEventType.Update.class, Folder.class, folder);
531    
532                    return folder;
533            }
534    
535            private final RepositoryEventTrigger _repositoryEventTrigger;
536    
537    }