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.service.ServiceContext;
028    import com.liferay.portal.kernel.util.OrderByComparator;
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 List<RepositoryEntry> getFoldersAndFileEntriesAndFileShortcuts(
351                            long folderId, int status, boolean includeMountFolders, int start,
352                            int end, OrderByComparator<?> obc)
353                    throws PortalException {
354    
355                    return getRepository().getFoldersAndFileEntriesAndFileShortcuts(
356                            folderId, status, includeMountFolders, start, end, obc);
357            }
358    
359            @Override
360            public int getFoldersAndFileEntriesAndFileShortcutsCount(
361                            long folderId, int status, boolean includeMountFolders)
362                    throws PortalException {
363    
364                    return getRepository().getFoldersAndFileEntriesAndFileShortcutsCount(
365                            folderId, status, includeMountFolders);
366            }
367    
368            @Override
369            public int getFoldersCount(long parentFolderId, boolean includeMountfolders)
370                    throws PortalException {
371    
372                    return getRepository().getFoldersCount(
373                            parentFolderId, includeMountfolders);
374            }
375    
376            @Override
377            public int getFoldersCount(
378                            long parentFolderId, int status, boolean includeMountfolders)
379                    throws PortalException {
380    
381                    return getRepository().getFoldersCount(
382                            parentFolderId, status, includeMountfolders);
383            }
384    
385            @Override
386            public List<FileEntry> getRepositoryFileEntries(
387                            long userId, long rootFolderId, int start, int end,
388                            OrderByComparator<FileEntry> obc)
389                    throws PortalException {
390    
391                    return getRepository().getRepositoryFileEntries(
392                            userId, rootFolderId, start, end, obc);
393            }
394    
395            @Override
396            public long getRepositoryId() {
397                    return getRepository().getRepositoryId();
398            }
399    
400            @Override
401            public FileEntry moveFileEntry(
402                            long userId, long fileEntryId, long newFolderId,
403                            ServiceContext serviceContext)
404                    throws PortalException {
405    
406                    LocalRepository localRepository = getRepository();
407    
408                    FileEntry fileEntry = localRepository.moveFileEntry(
409                            userId, fileEntryId, newFolderId, serviceContext);
410    
411                    _repositoryEventTrigger.trigger(
412                            RepositoryEventType.Move.class, FileEntry.class, fileEntry);
413    
414                    return fileEntry;
415            }
416    
417            @Override
418            public Folder moveFolder(
419                            long userId, long folderId, long parentFolderId,
420                            ServiceContext serviceContext)
421                    throws PortalException {
422    
423                    LocalRepository localRepository = getRepository();
424    
425                    Folder folder = localRepository.moveFolder(
426                            userId, folderId, parentFolderId, serviceContext);
427    
428                    _repositoryEventTrigger.trigger(
429                            RepositoryEventType.Move.class, Folder.class, folder);
430    
431                    return folder;
432            }
433    
434            @Override
435            public void revertFileEntry(
436                            long userId, long fileEntryId, String version,
437                            ServiceContext serviceContext)
438                    throws PortalException {
439    
440                    LocalRepository localRepository = getRepository();
441    
442                    localRepository.revertFileEntry(
443                            userId, fileEntryId, version, serviceContext);
444    
445                    FileEntry fileEntry = getFileEntry(fileEntryId);
446    
447                    _repositoryEventTrigger.trigger(
448                            RepositoryEventType.Update.class, FileEntry.class, fileEntry);
449            }
450    
451            /**
452             * @deprecated As of 7.0.0, with no direct replacement
453             */
454            @Deprecated
455            @Override
456            public void updateAsset(
457                            long userId, FileEntry fileEntry, FileVersion fileVersion,
458                            long[] assetCategoryIds, String[] assetTagNames,
459                            long[] assetLinkEntryIds)
460                    throws PortalException {
461    
462                    getRepository().updateAsset(
463                            userId, fileEntry, fileVersion, assetCategoryIds, assetTagNames,
464                            assetLinkEntryIds);
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, File file, ServiceContext serviceContext)
472                    throws PortalException {
473    
474                    LocalRepository localRepository = getRepository();
475    
476                    FileEntry fileEntry = localRepository.updateFileEntry(
477                            userId, fileEntryId, sourceFileName, mimeType, title, description,
478                            changeLog, majorVersion, file, serviceContext);
479    
480                    _repositoryEventTrigger.trigger(
481                            RepositoryEventType.Update.class, FileEntry.class, fileEntry);
482    
483                    return fileEntry;
484            }
485    
486            @Override
487            public FileEntry updateFileEntry(
488                            long userId, long fileEntryId, String sourceFileName,
489                            String mimeType, String title, String description, String changeLog,
490                            boolean majorVersion, InputStream is, long size,
491                            ServiceContext serviceContext)
492                    throws PortalException {
493    
494                    LocalRepository localRepository = getRepository();
495    
496                    FileEntry fileEntry = localRepository.updateFileEntry(
497                            userId, fileEntryId, sourceFileName, mimeType, title, description,
498                            changeLog, majorVersion, is, size, serviceContext);
499    
500                    _repositoryEventTrigger.trigger(
501                            RepositoryEventType.Update.class, FileEntry.class, fileEntry);
502    
503                    return fileEntry;
504            }
505    
506            @Override
507            public FileShortcut updateFileShortcut(
508                            long userId, long fileShortcutId, long folderId, long toFileEntryId,
509                            ServiceContext serviceContext)
510                    throws PortalException {
511    
512                    LocalRepository localRepository = getRepository();
513    
514                    FileShortcut fileShortcut = localRepository.updateFileShortcut(
515                            userId, fileShortcutId, folderId, toFileEntryId, serviceContext);
516    
517                    _repositoryEventTrigger.trigger(
518                            RepositoryEventType.Update.class, FileShortcut.class, fileShortcut);
519    
520                    return fileShortcut;
521            }
522    
523            @Override
524            public void updateFileShortcuts(
525                            long oldToFileEntryId, long newToFileEntryId)
526                    throws PortalException {
527    
528                    LocalRepository localRepository = getRepository();
529    
530                    FileEntry fileEntry = localRepository.getFileEntry(oldToFileEntryId);
531    
532                    fileEntry.getFileShortcuts();
533    
534                    localRepository.updateFileShortcuts(oldToFileEntryId, newToFileEntryId);
535            }
536    
537            @Override
538            public Folder updateFolder(
539                            long folderId, long parentFolderId, String name, String description,
540                            ServiceContext serviceContext)
541                    throws PortalException {
542    
543                    LocalRepository localRepository = getRepository();
544    
545                    Folder folder = localRepository.updateFolder(
546                            folderId, parentFolderId, name, description, serviceContext);
547    
548                    _repositoryEventTrigger.trigger(
549                            RepositoryEventType.Update.class, Folder.class, folder);
550    
551                    return folder;
552            }
553    
554            private final RepositoryEventTrigger _repositoryEventTrigger;
555    
556    }