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