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.proxy;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.kernel.exception.PortalException;
020    import com.liferay.portal.kernel.lock.Lock;
021    import com.liferay.portal.kernel.repository.BaseRepository;
022    import com.liferay.portal.kernel.repository.LocalRepository;
023    import com.liferay.portal.kernel.repository.capabilities.Capability;
024    import com.liferay.portal.kernel.repository.model.FileEntry;
025    import com.liferay.portal.kernel.repository.model.FileShortcut;
026    import com.liferay.portal.kernel.repository.model.FileVersion;
027    import com.liferay.portal.kernel.repository.model.Folder;
028    import com.liferay.portal.kernel.repository.model.RepositoryEntry;
029    import com.liferay.portal.kernel.search.Hits;
030    import com.liferay.portal.kernel.search.Query;
031    import com.liferay.portal.kernel.search.SearchContext;
032    import com.liferay.portal.kernel.search.SearchException;
033    import com.liferay.portal.kernel.util.OrderByComparator;
034    import com.liferay.portal.kernel.util.UnicodeProperties;
035    import com.liferay.portal.service.CompanyLocalService;
036    import com.liferay.portal.service.RepositoryEntryLocalService;
037    import com.liferay.portal.service.ServiceContext;
038    import com.liferay.portal.service.UserLocalService;
039    import com.liferay.portlet.asset.service.AssetEntryLocalService;
040    import com.liferay.portlet.documentlibrary.service.DLAppHelperLocalService;
041    import com.liferay.portlet.documentlibrary.service.DLFolderLocalService;
042    
043    import java.io.File;
044    import java.io.InputStream;
045    
046    import java.util.List;
047    
048    /**
049     * @author Mika Koivisto
050     */
051    @ProviderType
052    public class BaseRepositoryProxyBean
053            extends RepositoryModelProxyBean implements BaseRepository {
054    
055            public BaseRepositoryProxyBean(
056                    BaseRepository baseRepository, ClassLoader classLoader) {
057    
058                    super(classLoader);
059    
060                    _baseRepository = baseRepository;
061            }
062    
063            @Override
064            public FileEntry addFileEntry(
065                            long userId, long folderId, String sourceFileName, String mimeType,
066                            String title, String description, String changeLog, File file,
067                            ServiceContext serviceContext)
068                    throws PortalException {
069    
070                    FileEntry fileEntry = _baseRepository.addFileEntry(
071                            userId, folderId, sourceFileName, mimeType, title, description,
072                            changeLog, file, serviceContext);
073    
074                    return newFileEntryProxyBean(fileEntry);
075            }
076    
077            @Override
078            public FileEntry addFileEntry(
079                            long userId, long folderId, String sourceFileName, String mimeType,
080                            String title, String description, String changeLog, InputStream is,
081                            long size, ServiceContext serviceContext)
082                    throws PortalException {
083    
084                    FileEntry fileEntry = _baseRepository.addFileEntry(
085                            userId, folderId, sourceFileName, mimeType, title, description,
086                            changeLog, is, size, serviceContext);
087    
088                    return newFileEntryProxyBean(fileEntry);
089            }
090    
091            /**
092             * @deprecated As of 7.0.0, see {@link #addFileEntry(long, long, String,
093             *             String, String, String, String, File, ServiceContext)}
094             */
095            @Deprecated
096            @Override
097            public FileEntry addFileEntry(
098                            long folderId, String sourceFileName, String mimeType, String title,
099                            String description, String changeLog, File file,
100                            ServiceContext serviceContext)
101                    throws PortalException {
102    
103                    return addFileEntry(
104                            com.liferay.portal.kernel.repository.util.RepositoryUserUtil.
105                                    getUserId(),
106                            folderId, sourceFileName, mimeType, title, description, changeLog,
107                            file, serviceContext);
108            }
109    
110            /**
111             * @deprecated As of 7.0.0, see {@link #addFileEntry(long, long, String,
112             *             String, String, String, String, InputStream, long,
113             *             ServiceContext)}
114             */
115            @Deprecated
116            @Override
117            public FileEntry addFileEntry(
118                            long folderId, String sourceFileName, String mimeType, String title,
119                            String description, String changeLog, InputStream is, long size,
120                            ServiceContext serviceContext)
121                    throws PortalException {
122    
123                    return addFileEntry(
124                            com.liferay.portal.kernel.repository.util.RepositoryUserUtil.
125                                    getUserId(),
126                            folderId, sourceFileName, mimeType, title, description, changeLog,
127                            is, size, serviceContext);
128            }
129    
130            @Override
131            public FileShortcut addFileShortcut(
132                            long userId, long folderId, long toFileEntryId,
133                            ServiceContext serviceContext)
134                    throws PortalException {
135    
136                    FileShortcut fileShortcut = _baseRepository.addFileShortcut(
137                            userId, folderId, toFileEntryId, serviceContext);
138    
139                    return newFileShortcutProxyBean(fileShortcut);
140            }
141    
142            @Override
143            public Folder addFolder(
144                            long userId, long parentFolderId, String name, String description,
145                            ServiceContext serviceContext)
146                    throws PortalException {
147    
148                    Folder folder = _baseRepository.addFolder(
149                            userId, parentFolderId, name, description, serviceContext);
150    
151                    return newFolderProxyBean(folder);
152            }
153    
154            /**
155             * @deprecated As of 7.0.0, replaced by {@link #addFolder(long, long,
156             *             String, String, ServiceContext)}
157             */
158            @Deprecated
159            @Override
160            public Folder addFolder(
161                            long parentFolderId, String name, String description,
162                            ServiceContext serviceContext)
163                    throws PortalException {
164    
165                    return addFolder(
166                            com.liferay.portal.kernel.repository.util.RepositoryUserUtil.
167                                    getUserId(),
168                            parentFolderId, name, description, serviceContext);
169            }
170    
171            @Override
172            public FileVersion cancelCheckOut(long fileEntryId) throws PortalException {
173                    return _baseRepository.cancelCheckOut(fileEntryId);
174            }
175    
176            /**
177             * @deprecated As of 7.0.0, replaced by {@link #checkInFileEntry(long, long,
178             *             boolean, String, ServiceContext)}
179             */
180            @Deprecated
181            @Override
182            public void checkInFileEntry(
183                            long fileEntryId, boolean major, String changeLog,
184                            ServiceContext serviceContext)
185                    throws PortalException {
186    
187                    _baseRepository.checkInFileEntry(
188                            fileEntryId, major, changeLog, serviceContext);
189            }
190    
191            @Override
192            public void checkInFileEntry(
193                            long userId, long fileEntryId, boolean major, String changeLog,
194                            ServiceContext serviceContext)
195                    throws PortalException {
196    
197                    _baseRepository.checkInFileEntry(
198                            userId, fileEntryId, major, changeLog, serviceContext);
199            }
200    
201            @Override
202            public void checkInFileEntry(
203                            long userId, long fileEntryId, String lockUuid,
204                            ServiceContext serviceContext)
205                    throws PortalException {
206    
207                    _baseRepository.checkInFileEntry(
208                            userId, fileEntryId, lockUuid, serviceContext);
209            }
210    
211            /**
212             * @deprecated As of 6.2.0, replaced by {@link #checkInFileEntry(long,
213             *             String, ServiceContext)}
214             */
215            @Deprecated
216            @Override
217            public void checkInFileEntry(long fileEntryId, String lockUuid)
218                    throws PortalException {
219    
220                    _baseRepository.checkInFileEntry(fileEntryId, lockUuid);
221            }
222    
223            /**
224             * @deprecated As of 7.0.0, replaced by {@link #checkInFileEntry(long, long,
225             *             String, ServiceContext)}
226             */
227            @Deprecated
228            @Override
229            public void checkInFileEntry(
230                            long fileEntryId, String lockUuid, ServiceContext serviceContext)
231                    throws PortalException {
232    
233                    _baseRepository.checkInFileEntry(fileEntryId, lockUuid, serviceContext);
234            }
235    
236            @Override
237            public FileEntry checkOutFileEntry(
238                            long fileEntryId, ServiceContext serviceContext)
239                    throws PortalException {
240    
241                    FileEntry fileEntry = _baseRepository.checkOutFileEntry(
242                            fileEntryId, serviceContext);
243    
244                    return newFileEntryProxyBean(fileEntry);
245            }
246    
247            @Override
248            public FileEntry checkOutFileEntry(
249                            long fileEntryId, String owner, long expirationTime,
250                            ServiceContext serviceContext)
251                    throws PortalException {
252    
253                    FileEntry fileEntry = _baseRepository.checkOutFileEntry(
254                            fileEntryId, owner, expirationTime, serviceContext);
255    
256                    return newFileEntryProxyBean(fileEntry);
257            }
258    
259            @Override
260            public FileEntry copyFileEntry(
261                            long userId, long groupId, long fileEntryId, long destFolderId,
262                            ServiceContext serviceContext)
263                    throws PortalException {
264    
265                    return _baseRepository.copyFileEntry(
266                            userId, groupId, fileEntryId, destFolderId, serviceContext);
267            }
268    
269            /**
270             * @deprecated As of 7.0.0, replaced by {@link #copyFileEntry(long, long,
271             *             long, long, ServiceContext)}
272             */
273            @Deprecated
274            @Override
275            public FileEntry copyFileEntry(
276                            long groupId, long fileEntryId, long destFolderId,
277                            ServiceContext serviceContext)
278                    throws PortalException {
279    
280                    return copyFileEntry(
281                            com.liferay.portal.kernel.repository.util.RepositoryUserUtil.
282                                    getUserId(),
283                            groupId, fileEntryId, destFolderId, serviceContext);
284            }
285    
286            @Override
287            public void deleteAll() throws PortalException {
288                    _baseRepository.deleteAll();
289            }
290    
291            @Override
292            public void deleteFileEntry(long fileEntryId) throws PortalException {
293                    _baseRepository.deleteFileEntry(fileEntryId);
294            }
295    
296            @Override
297            public void deleteFileEntry(long folderId, String title)
298                    throws PortalException {
299    
300                    _baseRepository.deleteFileEntry(folderId, title);
301            }
302    
303            @Override
304            public void deleteFileShortcut(long fileShortcutId) throws PortalException {
305                    _baseRepository.deleteFileShortcut(fileShortcutId);
306            }
307    
308            @Override
309            public void deleteFileShortcuts(long toFileEntryId) throws PortalException {
310                    _baseRepository.deleteFileShortcuts(toFileEntryId);
311            }
312    
313            @Override
314            public void deleteFileVersion(long fileEntryId, String version)
315                    throws PortalException {
316    
317                    _baseRepository.deleteFileVersion(fileEntryId, version);
318            }
319    
320            @Override
321            public void deleteFolder(long folderId) throws PortalException {
322                    _baseRepository.deleteFolder(folderId);
323            }
324    
325            @Override
326            public void deleteFolder(long parentFolderId, String name)
327                    throws PortalException {
328    
329                    _baseRepository.deleteFolder(parentFolderId, name);
330            }
331    
332            @Override
333            public <T extends Capability> T getCapability(Class<T> capabilityClass) {
334                    return _baseRepository.getCapability(capabilityClass);
335            }
336    
337            @Override
338            public List<FileEntry> getFileEntries(
339                            long folderId, int status, int start, int end,
340                            OrderByComparator<FileEntry> obc)
341                    throws PortalException {
342    
343                    List<FileEntry> fileEntries = _baseRepository.getFileEntries(
344                            folderId, status, start, end, obc);
345    
346                    return toFileEntryProxyBeans(fileEntries);
347            }
348    
349            @Override
350            public List<FileEntry> getFileEntries(
351                            long folderId, int start, int end, OrderByComparator<FileEntry> obc)
352                    throws PortalException {
353    
354                    List<FileEntry> fileEntries = _baseRepository.getFileEntries(
355                            folderId, start, end, obc);
356    
357                    return toFileEntryProxyBeans(fileEntries);
358            }
359    
360            @Override
361            public List<FileEntry> getFileEntries(
362                            long folderId, long documentTypeId, int start, int end,
363                            OrderByComparator<FileEntry> obc)
364                    throws PortalException {
365    
366                    List<FileEntry> fileEntries = _baseRepository.getFileEntries(
367                            folderId, documentTypeId, start, end, obc);
368    
369                    return toFileEntryProxyBeans(fileEntries);
370            }
371    
372            @Override
373            public List<FileEntry> getFileEntries(
374                            long folderId, String[] mimeTypes, int start, int end,
375                            OrderByComparator<FileEntry> obc)
376                    throws PortalException {
377    
378                    List<FileEntry> fileEntries = _baseRepository.getFileEntries(
379                            folderId, mimeTypes, start, end, obc);
380    
381                    return toFileEntryProxyBeans(fileEntries);
382            }
383    
384            @Override
385            public List<RepositoryEntry> getFileEntriesAndFileShortcuts(
386                            long folderId, int status, int start, int end)
387                    throws PortalException {
388    
389                    List<RepositoryEntry> fileEntriesAndFileShortcuts =
390                            _baseRepository.getFileEntriesAndFileShortcuts(
391                                    folderId, status, start, end);
392    
393                    return toObjectProxyBeans(fileEntriesAndFileShortcuts);
394            }
395    
396            @Override
397            public int getFileEntriesAndFileShortcutsCount(long folderId, int status)
398                    throws PortalException {
399    
400                    return _baseRepository.getFileEntriesAndFileShortcutsCount(
401                            folderId, status);
402            }
403    
404            @Override
405            public int getFileEntriesAndFileShortcutsCount(
406                            long folderId, int status, String[] mimeTypes)
407                    throws PortalException {
408    
409                    return _baseRepository.getFileEntriesAndFileShortcutsCount(
410                            folderId, status, mimeTypes);
411            }
412    
413            @Override
414            public int getFileEntriesCount(long folderId) throws PortalException {
415                    return _baseRepository.getFileEntriesCount(folderId);
416            }
417    
418            @Override
419            public int getFileEntriesCount(long folderId, int status)
420                    throws PortalException {
421    
422                    return _baseRepository.getFileEntriesCount(folderId, status);
423            }
424    
425            @Override
426            public int getFileEntriesCount(long folderId, long documentTypeId)
427                    throws PortalException {
428    
429                    return _baseRepository.getFileEntriesCount(folderId, documentTypeId);
430            }
431    
432            @Override
433            public int getFileEntriesCount(long folderId, String[] mimeTypes)
434                    throws PortalException {
435    
436                    return _baseRepository.getFileEntriesCount(folderId, mimeTypes);
437            }
438    
439            @Override
440            public FileEntry getFileEntry(long fileEntryId) throws PortalException {
441                    FileEntry fileEntry = _baseRepository.getFileEntry(fileEntryId);
442    
443                    return newFileEntryProxyBean(fileEntry);
444            }
445    
446            @Override
447            public FileEntry getFileEntry(long folderId, String title)
448                    throws PortalException {
449    
450                    FileEntry fileEntry = _baseRepository.getFileEntry(folderId, title);
451    
452                    return newFileEntryProxyBean(fileEntry);
453            }
454    
455            @Override
456            public FileEntry getFileEntryByUuid(String uuid) throws PortalException {
457                    FileEntry fileEntry = _baseRepository.getFileEntryByUuid(uuid);
458    
459                    return newFileEntryProxyBean(fileEntry);
460            }
461    
462            @Override
463            public FileShortcut getFileShortcut(long fileShortcutId)
464                    throws PortalException {
465    
466                    FileShortcut fileShortcut = _baseRepository.getFileShortcut(
467                            fileShortcutId);
468    
469                    return newFileShortcutProxyBean(fileShortcut);
470            }
471    
472            @Override
473            public FileVersion getFileVersion(long fileVersionId)
474                    throws PortalException {
475    
476                    FileVersion fileVersion = _baseRepository.getFileVersion(fileVersionId);
477    
478                    return newFileVersionProxyBean(fileVersion);
479            }
480    
481            @Override
482            public Folder getFolder(long folderId) throws PortalException {
483                    Folder folder = _baseRepository.getFolder(folderId);
484    
485                    return newFolderProxyBean(folder);
486            }
487    
488            @Override
489            public Folder getFolder(long parentFolderId, String name)
490                    throws PortalException {
491    
492                    Folder folder = _baseRepository.getFolder(parentFolderId, name);
493    
494                    return newFolderProxyBean(folder);
495            }
496    
497            @Override
498            public List<Folder> getFolders(
499                            long parentFolderId, boolean includeMountfolders, int start,
500                            int end, OrderByComparator<Folder> obc)
501                    throws PortalException {
502    
503                    List<Folder> folders = _baseRepository.getFolders(
504                            parentFolderId, includeMountfolders, start, end, obc);
505    
506                    return toFolderProxyBeans(folders);
507            }
508    
509            @Override
510            public List<Folder> getFolders(
511                            long parentFolderId, int status, boolean includeMountfolders,
512                            int start, int end, OrderByComparator<Folder> obc)
513                    throws PortalException {
514    
515                    List<Folder> folders = _baseRepository.getFolders(
516                            parentFolderId, status, includeMountfolders, start, end, obc);
517    
518                    return toFolderProxyBeans(folders);
519            }
520    
521            @Override
522            public List<RepositoryEntry> getFoldersAndFileEntriesAndFileShortcuts(
523                            long folderId, int status, boolean includeMountFolders, int start,
524                            int end, OrderByComparator<?> obc)
525                    throws PortalException {
526    
527                    List<RepositoryEntry> foldersAndFileEntriesAndFileShortcuts =
528                            _baseRepository.getFoldersAndFileEntriesAndFileShortcuts(
529                                    folderId, status, includeMountFolders, start, end, obc);
530    
531                    return toObjectProxyBeans(foldersAndFileEntriesAndFileShortcuts);
532            }
533    
534            @Override
535            public List<RepositoryEntry> getFoldersAndFileEntriesAndFileShortcuts(
536                            long folderId, int status, String[] mimeTypes,
537                            boolean includeMountFolders, int start, int end,
538                            OrderByComparator<?> obc)
539                    throws PortalException {
540    
541                    List<RepositoryEntry> foldersAndFileEntriesAndFileShortcuts =
542                            _baseRepository.getFoldersAndFileEntriesAndFileShortcuts(
543                                    folderId, status, mimeTypes, includeMountFolders, start, end,
544                                    obc);
545    
546                    return toObjectProxyBeans(foldersAndFileEntriesAndFileShortcuts);
547            }
548    
549            @Override
550            public int getFoldersAndFileEntriesAndFileShortcutsCount(
551                            long folderId, int status, boolean includeMountFolders)
552                    throws PortalException {
553    
554                    return _baseRepository.getFoldersAndFileEntriesAndFileShortcutsCount(
555                            folderId, status, includeMountFolders);
556            }
557    
558            @Override
559            public int getFoldersAndFileEntriesAndFileShortcutsCount(
560                            long folderId, int status, String[] mimeTypes,
561                            boolean includeMountFolders)
562                    throws PortalException {
563    
564                    return _baseRepository.getFoldersAndFileEntriesAndFileShortcutsCount(
565                            folderId, status, mimeTypes, includeMountFolders);
566            }
567    
568            @Override
569            public int getFoldersCount(long parentFolderId, boolean includeMountfolders)
570                    throws PortalException {
571    
572                    return _baseRepository.getFoldersCount(
573                            parentFolderId, includeMountfolders);
574            }
575    
576            @Override
577            public int getFoldersCount(
578                            long parentFolderId, int status, boolean includeMountfolders)
579                    throws PortalException {
580    
581                    return _baseRepository.getFoldersCount(
582                            parentFolderId, status, includeMountfolders);
583            }
584    
585            @Override
586            public int getFoldersFileEntriesCount(List<Long> folderIds, int status)
587                    throws PortalException {
588    
589                    return _baseRepository.getFoldersFileEntriesCount(folderIds, status);
590            }
591    
592            @Override
593            public LocalRepository getLocalRepository() {
594                    LocalRepository localRepository = _baseRepository.getLocalRepository();
595    
596                    return newLocalRepositoryProxyBean(localRepository);
597            }
598    
599            @Override
600            public List<Folder> getMountFolders(
601                            long parentFolderId, int start, int end,
602                            OrderByComparator<Folder> obc)
603                    throws PortalException {
604    
605                    List<Folder> folders = _baseRepository.getMountFolders(
606                            parentFolderId, start, end, obc);
607    
608                    return toFolderProxyBeans(folders);
609            }
610    
611            @Override
612            public int getMountFoldersCount(long parentFolderId)
613                    throws PortalException {
614    
615                    return _baseRepository.getMountFoldersCount(parentFolderId);
616            }
617    
618            public BaseRepository getProxyBean() {
619                    return _baseRepository;
620            }
621    
622            @Override
623            public List<FileEntry> getRepositoryFileEntries(
624                            long userId, long rootFolderId, int start, int end,
625                            OrderByComparator<FileEntry> obc)
626                    throws PortalException {
627    
628                    List<FileEntry> fileEntries = _baseRepository.getRepositoryFileEntries(
629                            userId, rootFolderId, start, end, obc);
630    
631                    return toFileEntryProxyBeans(fileEntries);
632            }
633    
634            @Override
635            public List<FileEntry> getRepositoryFileEntries(
636                            long userId, long rootFolderId, String[] mimeTypes, int status,
637                            int start, int end, OrderByComparator<FileEntry> obc)
638                    throws PortalException {
639    
640                    List<FileEntry> fileEntries = _baseRepository.getRepositoryFileEntries(
641                            userId, rootFolderId, mimeTypes, status, start, end, obc);
642    
643                    return toFileEntryProxyBeans(fileEntries);
644            }
645    
646            @Override
647            public int getRepositoryFileEntriesCount(long userId, long rootFolderId)
648                    throws PortalException {
649    
650                    return _baseRepository.getRepositoryFileEntriesCount(
651                            userId, rootFolderId);
652            }
653    
654            @Override
655            public int getRepositoryFileEntriesCount(
656                            long userId, long rootFolderId, String[] mimeTypes, int status)
657                    throws PortalException {
658    
659                    return _baseRepository.getRepositoryFileEntriesCount(
660                            userId, rootFolderId, mimeTypes, status);
661            }
662    
663            @Override
664            public long getRepositoryId() {
665                    return _baseRepository.getRepositoryId();
666            }
667    
668            @Override
669            public void getSubfolderIds(List<Long> folderIds, long folderId)
670                    throws PortalException {
671    
672                    _baseRepository.getSubfolderIds(folderIds, folderId);
673            }
674    
675            @Override
676            public List<Long> getSubfolderIds(long folderId, boolean recurse)
677                    throws PortalException {
678    
679                    return _baseRepository.getSubfolderIds(folderId, recurse);
680            }
681    
682            @Deprecated
683            @Override
684            public String[] getSupportedConfigurations() {
685                    return _baseRepository.getSupportedConfigurations();
686            }
687    
688            @Deprecated
689            @Override
690            public String[][] getSupportedParameters() {
691                    return _baseRepository.getSupportedParameters();
692            }
693    
694            @Override
695            public void initRepository() throws PortalException {
696                    _baseRepository.initRepository();
697            }
698    
699            @Override
700            public <T extends Capability> boolean isCapabilityProvided(
701                    Class<T> capabilityClass) {
702    
703                    return _baseRepository.isCapabilityProvided(capabilityClass);
704            }
705    
706            @Override
707            public Lock lockFolder(long folderId) throws PortalException {
708                    Lock lock = _baseRepository.lockFolder(folderId);
709    
710                    return (Lock)newProxyInstance(lock, Lock.class);
711            }
712    
713            @Override
714            public Lock lockFolder(
715                            long folderId, String owner, boolean inheritable,
716                            long expirationTime)
717                    throws PortalException {
718    
719                    Lock lock = _baseRepository.lockFolder(
720                            folderId, owner, inheritable, expirationTime);
721    
722                    return (Lock)newProxyInstance(lock, Lock.class);
723            }
724    
725            @Override
726            public FileEntry moveFileEntry(
727                            long userId, long fileEntryId, long newFolderId,
728                            ServiceContext serviceContext)
729                    throws PortalException {
730    
731                    FileEntry fileEntry = _baseRepository.moveFileEntry(
732                            userId, fileEntryId, newFolderId, serviceContext);
733    
734                    return newFileEntryProxyBean(fileEntry);
735            }
736    
737            /**
738             * @deprecated As of 7.0.0, replaced by {@link #moveFileEntry(long, long,
739             *             long, ServiceContext)}
740             */
741            @Deprecated
742            @Override
743            public FileEntry moveFileEntry(
744                            long fileEntryId, long newFolderId, ServiceContext serviceContext)
745                    throws PortalException {
746    
747                    return moveFileEntry(
748                            com.liferay.portal.kernel.repository.util.RepositoryUserUtil.
749                                    getUserId(),
750                            fileEntryId, newFolderId, serviceContext);
751            }
752    
753            @Override
754            public Folder moveFolder(
755                            long userId, long folderId, long parentFolderId,
756                            ServiceContext serviceContext)
757                    throws PortalException {
758    
759                    Folder folder = _baseRepository.moveFolder(
760                            userId, folderId, parentFolderId, serviceContext);
761    
762                    return newFolderProxyBean(folder);
763            }
764    
765            /**
766             * @deprecated As of 7.0.0, replaced by {@link #moveFolder(long, long, long,
767             *             ServiceContext)}
768             */
769            @Deprecated
770            @Override
771            public Folder moveFolder(
772                            long folderId, long newParentFolderId,
773                            ServiceContext serviceContext)
774                    throws PortalException {
775    
776                    return moveFolder(
777                            com.liferay.portal.kernel.repository.util.RepositoryUserUtil.
778                                    getUserId(),
779                            folderId, newParentFolderId, serviceContext);
780            }
781    
782            @Override
783            public Lock refreshFileEntryLock(
784                            String lockUuid, long companyId, long expirationTime)
785                    throws PortalException {
786    
787                    Lock lock = _baseRepository.refreshFileEntryLock(
788                            lockUuid, companyId, expirationTime);
789    
790                    return (Lock)newProxyInstance(lock, Lock.class);
791            }
792    
793            @Override
794            public Lock refreshFolderLock(
795                            String lockUuid, long companyId, long expirationTime)
796                    throws PortalException {
797    
798                    Lock lock = _baseRepository.refreshFolderLock(
799                            lockUuid, companyId, expirationTime);
800    
801                    return (Lock)newProxyInstance(lock, Lock.class);
802            }
803    
804            @Override
805            public void revertFileEntry(
806                            long userId, long fileEntryId, String version,
807                            ServiceContext serviceContext)
808                    throws PortalException {
809    
810                    _baseRepository.revertFileEntry(
811                            userId, fileEntryId, version, serviceContext);
812            }
813    
814            /**
815             * @deprecated As of 7.0.0, replaced by {@link #revertFileEntry(long, long,
816             *             String, ServiceContext)}
817             */
818            @Deprecated
819            @Override
820            public void revertFileEntry(
821                            long fileEntryId, String version, ServiceContext serviceContext)
822                    throws PortalException {
823    
824                    _baseRepository.revertFileEntry(fileEntryId, version, serviceContext);
825            }
826    
827            @Override
828            public Hits search(long creatorUserId, int status, int start, int end)
829                    throws PortalException {
830    
831                    return _baseRepository.search(creatorUserId, status, start, end);
832            }
833    
834            @Override
835            public Hits search(
836                            long creatorUserId, long folderId, String[] mimeTypes, int status,
837                            int start, int end)
838                    throws PortalException {
839    
840                    return _baseRepository.search(
841                            creatorUserId, folderId, mimeTypes, status, start, end);
842            }
843    
844            @Override
845            public Hits search(SearchContext searchContext) throws SearchException {
846                    return _baseRepository.search(searchContext);
847            }
848    
849            @Override
850            public Hits search(SearchContext searchContext, Query query)
851                    throws SearchException {
852    
853                    return _baseRepository.search(searchContext, query);
854            }
855    
856            @Override
857            public void setAssetEntryLocalService(
858                    AssetEntryLocalService assetEntryLocalService) {
859    
860                    _baseRepository.setAssetEntryLocalService(assetEntryLocalService);
861            }
862    
863            @Override
864            public void setCompanyId(long companyId) {
865                    _baseRepository.setCompanyId(companyId);
866            }
867    
868            @Override
869            public void setCompanyLocalService(
870                    CompanyLocalService companyLocalService) {
871    
872                    _baseRepository.setCompanyLocalService(companyLocalService);
873            }
874    
875            @Override
876            public void setDLAppHelperLocalService(
877                    DLAppHelperLocalService dlAppHelperLocalService) {
878    
879                    _baseRepository.setDLAppHelperLocalService(dlAppHelperLocalService);
880            }
881    
882            @Override
883            public void setDLFolderLocalService(
884                    DLFolderLocalService dlFolderLocalService) {
885    
886                    _baseRepository.setDLFolderLocalService(dlFolderLocalService);
887            }
888    
889            @Override
890            public void setGroupId(long groupId) {
891                    _baseRepository.setGroupId(groupId);
892            }
893    
894            @Override
895            public void setRepositoryEntryLocalService(
896                    RepositoryEntryLocalService repositoryEntryLocalService) {
897    
898                    _baseRepository.setRepositoryEntryLocalService(
899                            repositoryEntryLocalService);
900            }
901    
902            @Override
903            public void setRepositoryId(long repositoryId) {
904                    _baseRepository.setRepositoryId(repositoryId);
905            }
906    
907            @Override
908            public void setTypeSettingsProperties(
909                    UnicodeProperties typeSettingsProperties) {
910    
911                    _baseRepository.setTypeSettingsProperties(typeSettingsProperties);
912            }
913    
914            @Override
915            public void setUserLocalService(UserLocalService userLocalService) {
916                    _baseRepository.setUserLocalService(userLocalService);
917            }
918    
919            @Override
920            public void unlockFolder(long folderId, String lockUuid)
921                    throws PortalException {
922    
923                    _baseRepository.unlockFolder(folderId, lockUuid);
924            }
925    
926            @Override
927            public void unlockFolder(long parentFolderId, String name, String lockUuid)
928                    throws PortalException {
929    
930                    _baseRepository.unlockFolder(parentFolderId, name, lockUuid);
931            }
932    
933            @Override
934            public FileEntry updateFileEntry(
935                            long userId, long fileEntryId, String sourceFileName,
936                            String mimeType, String title, String description, String changeLog,
937                            boolean majorVersion, File file, ServiceContext serviceContext)
938                    throws PortalException {
939    
940                    FileEntry fileEntry = _baseRepository.updateFileEntry(
941                            userId, fileEntryId, sourceFileName, mimeType, title, description,
942                            changeLog, majorVersion, file, serviceContext);
943    
944                    return newFileEntryProxyBean(fileEntry);
945            }
946    
947            @Override
948            public FileEntry updateFileEntry(
949                            long userId, long fileEntryId, String sourceFileName,
950                            String mimeType, String title, String description, String changeLog,
951                            boolean majorVersion, InputStream is, long size,
952                            ServiceContext serviceContext)
953                    throws PortalException {
954    
955                    FileEntry fileEntry = _baseRepository.updateFileEntry(
956                            userId, fileEntryId, sourceFileName, mimeType, title, description,
957                            changeLog, majorVersion, is, size, serviceContext);
958    
959                    return newFileEntryProxyBean(fileEntry);
960            }
961    
962            /**
963             * @deprecated As of 7.0.0, replaced by {@link #updateFileEntry(long, long,
964             *             String, String, String, String, String, boolean, File,
965             *             ServiceContext)}
966             */
967            @Deprecated
968            @Override
969            public FileEntry updateFileEntry(
970                            long fileEntryId, String sourceFileName, String mimeType,
971                            String title, String description, String changeLog,
972                            boolean majorVersion, File file, ServiceContext serviceContext)
973                    throws PortalException {
974    
975                    FileEntry fileEntry = _baseRepository.updateFileEntry(
976                            fileEntryId, sourceFileName, mimeType, title, description,
977                            changeLog, majorVersion, file, serviceContext);
978    
979                    return newFileEntryProxyBean(fileEntry);
980            }
981    
982            /**
983             * @deprecated As of 7.0.0, replaced by {@link #updateFileEntry(long, long,
984             *             String, String, String, String, String, boolean, InputStream,
985             *             long, ServiceContext)}
986             */
987            @Deprecated
988            @Override
989            public FileEntry updateFileEntry(
990                            long fileEntryId, String sourceFileName, String mimeType,
991                            String title, String description, String changeLog,
992                            boolean majorVersion, InputStream is, long size,
993                            ServiceContext serviceContext)
994                    throws PortalException {
995    
996                    FileEntry fileEntry = _baseRepository.updateFileEntry(
997                            fileEntryId, sourceFileName, mimeType, title, description,
998                            changeLog, majorVersion, is, size, serviceContext);
999    
1000                    return newFileEntryProxyBean(fileEntry);
1001            }
1002    
1003            @Override
1004            public FileShortcut updateFileShortcut(
1005                            long userId, long fileShortcutId, long folderId, long toFileEntryId,
1006                            ServiceContext serviceContext)
1007                    throws PortalException {
1008    
1009                    FileShortcut fileShortcut = _baseRepository.updateFileShortcut(
1010                            userId, fileShortcutId, folderId, toFileEntryId, serviceContext);
1011    
1012                    return newFileShortcutProxyBean(fileShortcut);
1013            }
1014    
1015            @Override
1016            public void updateFileShortcuts(
1017                            long oldToFileEntryId, long newToFileEntryId)
1018                    throws PortalException {
1019    
1020                    _baseRepository.updateFileShortcuts(oldToFileEntryId, newToFileEntryId);
1021            }
1022    
1023            @Override
1024            public Folder updateFolder(
1025                            long folderId, long parentFolderId, String name, String description,
1026                            ServiceContext serviceContext)
1027                    throws PortalException {
1028    
1029                    Folder folder = _baseRepository.updateFolder(
1030                            folderId, parentFolderId, name, description, serviceContext);
1031    
1032                    return newFolderProxyBean(folder);
1033            }
1034    
1035            @Override
1036            public Folder updateFolder(
1037                            long folderId, String name, String description,
1038                            ServiceContext serviceContext)
1039                    throws PortalException {
1040    
1041                    Folder folder = _baseRepository.updateFolder(
1042                            folderId, name, description, serviceContext);
1043    
1044                    return newFolderProxyBean(folder);
1045            }
1046    
1047            @Override
1048            public boolean verifyFileEntryCheckOut(long fileEntryId, String lockUuid)
1049                    throws PortalException {
1050    
1051                    return _baseRepository.verifyFileEntryCheckOut(fileEntryId, lockUuid);
1052            }
1053    
1054            @Override
1055            public boolean verifyFileEntryLock(long fileEntryId, String lockUuid)
1056                    throws PortalException {
1057    
1058                    return _baseRepository.verifyFileEntryLock(fileEntryId, lockUuid);
1059            }
1060    
1061            @Override
1062            public boolean verifyInheritableLock(long folderId, String lockUuid)
1063                    throws PortalException {
1064    
1065                    return _baseRepository.verifyInheritableLock(folderId, lockUuid);
1066            }
1067    
1068            private final BaseRepository _baseRepository;
1069    
1070    }