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.repository.BaseRepository;
021    import com.liferay.portal.kernel.repository.LocalRepository;
022    import com.liferay.portal.kernel.repository.capabilities.Capability;
023    import com.liferay.portal.kernel.repository.model.FileEntry;
024    import com.liferay.portal.kernel.repository.model.FileVersion;
025    import com.liferay.portal.kernel.repository.model.Folder;
026    import com.liferay.portal.kernel.search.Hits;
027    import com.liferay.portal.kernel.search.Query;
028    import com.liferay.portal.kernel.search.SearchContext;
029    import com.liferay.portal.kernel.search.SearchException;
030    import com.liferay.portal.kernel.util.OrderByComparator;
031    import com.liferay.portal.kernel.util.UnicodeProperties;
032    import com.liferay.portal.model.Lock;
033    import com.liferay.portal.service.CompanyLocalService;
034    import com.liferay.portal.service.RepositoryEntryLocalService;
035    import com.liferay.portal.service.ServiceContext;
036    import com.liferay.portal.service.UserLocalService;
037    import com.liferay.portlet.asset.service.AssetEntryLocalService;
038    import com.liferay.portlet.documentlibrary.service.DLAppHelperLocalService;
039    
040    import java.io.File;
041    import java.io.InputStream;
042    
043    import java.util.List;
044    
045    /**
046     * @author Mika Koivisto
047     */
048    @ProviderType
049    public class BaseRepositoryProxyBean
050            extends RepositoryModelProxyBean implements BaseRepository {
051    
052            public BaseRepositoryProxyBean(
053                    BaseRepository baseRepository, ClassLoader classLoader) {
054    
055                    super(classLoader);
056    
057                    _baseRepository = baseRepository;
058            }
059    
060            @Override
061            public FileEntry addFileEntry(
062                            long folderId, String sourceFileName, String mimeType, String title,
063                            String description, String changeLog, File file,
064                            ServiceContext serviceContext)
065                    throws PortalException {
066    
067                    FileEntry fileEntry = _baseRepository.addFileEntry(
068                            folderId, sourceFileName, mimeType, title, description, changeLog,
069                            file, serviceContext);
070    
071                    return newFileEntryProxyBean(fileEntry);
072            }
073    
074            @Override
075            public FileEntry addFileEntry(
076                            long folderId, String sourceFileName, String mimeType, String title,
077                            String description, String changeLog, InputStream is, long size,
078                            ServiceContext serviceContext)
079                    throws PortalException {
080    
081                    FileEntry fileEntry = _baseRepository.addFileEntry(
082                            folderId, sourceFileName, mimeType, title, description, changeLog,
083                            is, size, serviceContext);
084    
085                    return newFileEntryProxyBean(fileEntry);
086            }
087    
088            @Override
089            public Folder addFolder(
090                            long parentFolderId, String name, String description,
091                            ServiceContext serviceContext)
092                    throws PortalException {
093    
094                    Folder folder = _baseRepository.addFolder(
095                            parentFolderId, name, description, serviceContext);
096    
097                    return newFolderProxyBean(folder);
098            }
099    
100            @Override
101            public FileVersion cancelCheckOut(long fileEntryId) throws PortalException {
102                    return _baseRepository.cancelCheckOut(fileEntryId);
103            }
104    
105            @Override
106            public void checkInFileEntry(
107                            long fileEntryId, boolean major, String changeLog,
108                            ServiceContext serviceContext)
109                    throws PortalException {
110    
111                    _baseRepository.checkInFileEntry(
112                            fileEntryId, major, changeLog, serviceContext);
113            }
114    
115            /**
116             * @deprecated As of 6.2.0, replaced by {@link #checkInFileEntry(long,
117             *             String, ServiceContext)}
118             */
119            @Deprecated
120            @Override
121            public void checkInFileEntry(long fileEntryId, String lockUuid)
122                    throws PortalException {
123    
124                    _baseRepository.checkInFileEntry(fileEntryId, lockUuid);
125            }
126    
127            @Override
128            public void checkInFileEntry(
129                            long fileEntryId, String lockUuid, ServiceContext serviceContext)
130                    throws PortalException {
131    
132                    _baseRepository.checkInFileEntry(fileEntryId, lockUuid, serviceContext);
133            }
134    
135            @Override
136            public FileEntry checkOutFileEntry(
137                            long fileEntryId, ServiceContext serviceContext)
138                    throws PortalException {
139    
140                    FileEntry fileEntry = _baseRepository.checkOutFileEntry(
141                            fileEntryId, serviceContext);
142    
143                    return newFileEntryProxyBean(fileEntry);
144            }
145    
146            @Override
147            public FileEntry checkOutFileEntry(
148                            long fileEntryId, String owner, long expirationTime,
149                            ServiceContext serviceContext)
150                    throws PortalException {
151    
152                    FileEntry fileEntry = _baseRepository.checkOutFileEntry(
153                            fileEntryId, owner, expirationTime, serviceContext);
154    
155                    return newFileEntryProxyBean(fileEntry);
156            }
157    
158            @Override
159            public FileEntry copyFileEntry(
160                            long groupId, long fileEntryId, long destFolderId,
161                            ServiceContext serviceContext)
162                    throws PortalException {
163    
164                    return _baseRepository.copyFileEntry(
165                            groupId, fileEntryId, destFolderId, serviceContext);
166            }
167    
168            @Override
169            public void deleteFileEntry(long fileEntryId) throws PortalException {
170                    _baseRepository.deleteFileEntry(fileEntryId);
171            }
172    
173            @Override
174            public void deleteFileEntry(long folderId, String title)
175                    throws PortalException {
176    
177                    _baseRepository.deleteFileEntry(folderId, title);
178            }
179    
180            @Override
181            public void deleteFileVersion(long fileEntryId, String version)
182                    throws PortalException {
183    
184                    _baseRepository.deleteFileVersion(fileEntryId, version);
185            }
186    
187            @Override
188            public void deleteFolder(long folderId) throws PortalException {
189                    _baseRepository.deleteFolder(folderId);
190            }
191    
192            @Override
193            public void deleteFolder(long parentFolderId, String name)
194                    throws PortalException {
195    
196                    _baseRepository.deleteFolder(parentFolderId, name);
197            }
198    
199            @Override
200            public <T extends Capability> T getCapability(Class<T> capabilityClass) {
201                    return _baseRepository.getCapability(capabilityClass);
202            }
203    
204            @Override
205            public List<FileEntry> getFileEntries(
206                            long folderId, int start, int end, OrderByComparator<FileEntry> obc)
207                    throws PortalException {
208    
209                    List<FileEntry> fileEntries = _baseRepository.getFileEntries(
210                            folderId, start, end, obc);
211    
212                    return toFileEntryProxyBeans(fileEntries);
213            }
214    
215            @Override
216            public List<FileEntry> getFileEntries(
217                            long folderId, long documentTypeId, int start, int end,
218                            OrderByComparator<FileEntry> obc)
219                    throws PortalException {
220    
221                    List<FileEntry> fileEntries = _baseRepository.getFileEntries(
222                            folderId, documentTypeId, start, end, obc);
223    
224                    return toFileEntryProxyBeans(fileEntries);
225            }
226    
227            @Override
228            public List<FileEntry> getFileEntries(
229                            long folderId, String[] mimeTypes, int start, int end,
230                            OrderByComparator<FileEntry> obc)
231                    throws PortalException {
232    
233                    List<FileEntry> fileEntries = _baseRepository.getFileEntries(
234                            folderId, mimeTypes, start, end, obc);
235    
236                    return toFileEntryProxyBeans(fileEntries);
237            }
238    
239            @Override
240            public List<Object> getFileEntriesAndFileShortcuts(
241                            long folderId, int status, int start, int end)
242                    throws PortalException {
243    
244                    List<Object> objects = _baseRepository.getFileEntriesAndFileShortcuts(
245                            folderId, status, start, end);
246    
247                    return toObjectProxyBeans(objects);
248            }
249    
250            @Override
251            public int getFileEntriesAndFileShortcutsCount(long folderId, int status)
252                    throws PortalException {
253    
254                    return _baseRepository.getFileEntriesAndFileShortcutsCount(
255                            folderId, status);
256            }
257    
258            @Override
259            public int getFileEntriesAndFileShortcutsCount(
260                            long folderId, int status, String[] mimeTypes)
261                    throws PortalException {
262    
263                    return _baseRepository.getFileEntriesAndFileShortcutsCount(
264                            folderId, status, mimeTypes);
265            }
266    
267            @Override
268            public int getFileEntriesCount(long folderId) throws PortalException {
269                    return _baseRepository.getFileEntriesCount(folderId);
270            }
271    
272            @Override
273            public int getFileEntriesCount(long folderId, long documentTypeId)
274                    throws PortalException {
275    
276                    return _baseRepository.getFileEntriesCount(folderId, documentTypeId);
277            }
278    
279            @Override
280            public int getFileEntriesCount(long folderId, String[] mimeTypes)
281                    throws PortalException {
282    
283                    return _baseRepository.getFileEntriesCount(folderId, mimeTypes);
284            }
285    
286            @Override
287            public FileEntry getFileEntry(long fileEntryId) throws PortalException {
288                    FileEntry fileEntry = _baseRepository.getFileEntry(fileEntryId);
289    
290                    return newFileEntryProxyBean(fileEntry);
291            }
292    
293            @Override
294            public FileEntry getFileEntry(long folderId, String title)
295                    throws PortalException {
296    
297                    FileEntry fileEntry = _baseRepository.getFileEntry(folderId, title);
298    
299                    return newFileEntryProxyBean(fileEntry);
300            }
301    
302            @Override
303            public FileEntry getFileEntryByUuid(String uuid) throws PortalException {
304                    FileEntry fileEntry = _baseRepository.getFileEntryByUuid(uuid);
305    
306                    return newFileEntryProxyBean(fileEntry);
307            }
308    
309            @Override
310            public FileVersion getFileVersion(long fileVersionId)
311                    throws PortalException {
312    
313                    FileVersion fileVersion = _baseRepository.getFileVersion(fileVersionId);
314    
315                    return newFileVersionProxyBean(fileVersion);
316            }
317    
318            @Override
319            public Folder getFolder(long folderId) throws PortalException {
320                    Folder folder = _baseRepository.getFolder(folderId);
321    
322                    return newFolderProxyBean(folder);
323            }
324    
325            @Override
326            public Folder getFolder(long parentFolderId, String name)
327                    throws PortalException {
328    
329                    Folder folder = _baseRepository.getFolder(parentFolderId, name);
330    
331                    return newFolderProxyBean(folder);
332            }
333    
334            @Override
335            public List<Folder> getFolders(
336                            long parentFolderId, boolean includeMountfolders, int start,
337                            int end, OrderByComparator<Folder> obc)
338                    throws PortalException {
339    
340                    List<Folder> folders = _baseRepository.getFolders(
341                            parentFolderId, includeMountfolders, start, end, obc);
342    
343                    return toFolderProxyBeans(folders);
344            }
345    
346            @Override
347            public List<Folder> getFolders(
348                            long parentFolderId, int status, boolean includeMountfolders,
349                            int start, int end, OrderByComparator<Folder> obc)
350                    throws PortalException {
351    
352                    List<Folder> folders = _baseRepository.getFolders(
353                            parentFolderId, status, includeMountfolders, start, end, obc);
354    
355                    return toFolderProxyBeans(folders);
356            }
357    
358            @Override
359            public List<Object> getFoldersAndFileEntriesAndFileShortcuts(
360                            long folderId, int status, boolean includeMountFolders, int start,
361                            int end, OrderByComparator<?> obc)
362                    throws PortalException {
363    
364                    List<Object> objects =
365                            _baseRepository.getFoldersAndFileEntriesAndFileShortcuts(
366                                    folderId, status, includeMountFolders, start, end, obc);
367    
368                    return toObjectProxyBeans(objects);
369            }
370    
371            @Override
372            public List<Object> getFoldersAndFileEntriesAndFileShortcuts(
373                            long folderId, int status, String[] mimeTypes,
374                            boolean includeMountFolders, int start, int end,
375                            OrderByComparator<?> obc)
376                    throws PortalException {
377    
378                    List<Object> objects =
379                            _baseRepository.getFoldersAndFileEntriesAndFileShortcuts(
380                                    folderId, status, mimeTypes, includeMountFolders, start, end,
381                                    obc);
382    
383                    return toObjectProxyBeans(objects);
384            }
385    
386            @Override
387            public int getFoldersAndFileEntriesAndFileShortcutsCount(
388                            long folderId, int status, boolean includeMountFolders)
389                    throws PortalException {
390    
391                    return _baseRepository.getFoldersAndFileEntriesAndFileShortcutsCount(
392                            folderId, status, includeMountFolders);
393            }
394    
395            @Override
396            public int getFoldersAndFileEntriesAndFileShortcutsCount(
397                            long folderId, int status, String[] mimeTypes,
398                            boolean includeMountFolders)
399                    throws PortalException {
400    
401                    return _baseRepository.getFoldersAndFileEntriesAndFileShortcutsCount(
402                            folderId, status, mimeTypes, includeMountFolders);
403            }
404    
405            @Override
406            public int getFoldersCount(long parentFolderId, boolean includeMountfolders)
407                    throws PortalException {
408    
409                    return _baseRepository.getFoldersCount(
410                            parentFolderId, includeMountfolders);
411            }
412    
413            @Override
414            public int getFoldersCount(
415                            long parentFolderId, int status, boolean includeMountfolders)
416                    throws PortalException {
417    
418                    return _baseRepository.getFoldersCount(
419                            parentFolderId, status, includeMountfolders);
420            }
421    
422            @Override
423            public int getFoldersFileEntriesCount(List<Long> folderIds, int status)
424                    throws PortalException {
425    
426                    return _baseRepository.getFoldersFileEntriesCount(folderIds, status);
427            }
428    
429            @Override
430            public LocalRepository getLocalRepository() {
431                    LocalRepository localRepository = _baseRepository.getLocalRepository();
432    
433                    return newLocalRepositoryProxyBean(localRepository);
434            }
435    
436            @Override
437            public List<Folder> getMountFolders(
438                            long parentFolderId, int start, int end,
439                            OrderByComparator<Folder> obc)
440                    throws PortalException {
441    
442                    List<Folder> folders = _baseRepository.getMountFolders(
443                            parentFolderId, start, end, obc);
444    
445                    return toFolderProxyBeans(folders);
446            }
447    
448            @Override
449            public int getMountFoldersCount(long parentFolderId)
450                    throws PortalException {
451    
452                    return _baseRepository.getMountFoldersCount(parentFolderId);
453            }
454    
455            public BaseRepository getProxyBean() {
456                    return _baseRepository;
457            }
458    
459            @Override
460            public List<FileEntry> getRepositoryFileEntries(
461                            long userId, long rootFolderId, int start, int end,
462                            OrderByComparator<FileEntry> obc)
463                    throws PortalException {
464    
465                    List<FileEntry> fileEntries = _baseRepository.getRepositoryFileEntries(
466                            userId, rootFolderId, start, end, obc);
467    
468                    return toFileEntryProxyBeans(fileEntries);
469            }
470    
471            @Override
472            public List<FileEntry> getRepositoryFileEntries(
473                            long userId, long rootFolderId, String[] mimeTypes, int status,
474                            int start, int end, OrderByComparator<FileEntry> obc)
475                    throws PortalException {
476    
477                    List<FileEntry> fileEntries = _baseRepository.getRepositoryFileEntries(
478                            userId, rootFolderId, mimeTypes, status, start, end, obc);
479    
480                    return toFileEntryProxyBeans(fileEntries);
481            }
482    
483            @Override
484            public int getRepositoryFileEntriesCount(long userId, long rootFolderId)
485                    throws PortalException {
486    
487                    return _baseRepository.getRepositoryFileEntriesCount(
488                            userId, rootFolderId);
489            }
490    
491            @Override
492            public int getRepositoryFileEntriesCount(
493                            long userId, long rootFolderId, String[] mimeTypes, int status)
494                    throws PortalException {
495    
496                    return _baseRepository.getRepositoryFileEntriesCount(
497                            userId, rootFolderId, mimeTypes, status);
498            }
499    
500            @Override
501            public long getRepositoryId() {
502                    return _baseRepository.getRepositoryId();
503            }
504    
505            @Override
506            public void getSubfolderIds(List<Long> folderIds, long folderId)
507                    throws PortalException {
508    
509                    _baseRepository.getSubfolderIds(folderIds, folderId);
510            }
511    
512            @Override
513            public List<Long> getSubfolderIds(long folderId, boolean recurse)
514                    throws PortalException {
515    
516                    return _baseRepository.getSubfolderIds(folderId, recurse);
517            }
518    
519            @Override
520            public String[] getSupportedConfigurations() {
521                    return _baseRepository.getSupportedConfigurations();
522            }
523    
524            @Override
525            public String[][] getSupportedParameters() {
526                    return _baseRepository.getSupportedParameters();
527            }
528    
529            @Override
530            public void initRepository() throws PortalException {
531                    _baseRepository.initRepository();
532            }
533    
534            @Override
535            public <T extends Capability> boolean isCapabilityProvided(
536                    Class<T> capabilityClass) {
537    
538                    return _baseRepository.isCapabilityProvided(capabilityClass);
539            }
540    
541            /**
542             * @deprecated As of 6.2.0, replaced by {@link #checkOutFileEntry(long,
543             *             ServiceContext)}
544             */
545            @Deprecated
546            @Override
547            public Lock lockFileEntry(long fileEntryId) throws PortalException {
548                    Lock lock = _baseRepository.lockFileEntry(fileEntryId);
549    
550                    return (Lock)newProxyInstance(lock, Lock.class);
551            }
552    
553            /**
554             * @deprecated As of 6.2.0, replaced by {@link #checkOutFileEntry(long,
555             *             String, long, ServiceContext)}
556             */
557            @Deprecated
558            @Override
559            public Lock lockFileEntry(
560                            long fileEntryId, String owner, long expirationTime)
561                    throws PortalException {
562    
563                    Lock lock = _baseRepository.lockFileEntry(
564                            fileEntryId, owner, expirationTime);
565    
566                    return (Lock)newProxyInstance(lock, Lock.class);
567            }
568    
569            @Override
570            public Lock lockFolder(long folderId) throws PortalException {
571                    Lock lock = _baseRepository.lockFolder(folderId);
572    
573                    return (Lock)newProxyInstance(lock, Lock.class);
574            }
575    
576            @Override
577            public Lock lockFolder(
578                            long folderId, String owner, boolean inheritable,
579                            long expirationTime)
580                    throws PortalException {
581    
582                    Lock lock = _baseRepository.lockFolder(
583                            folderId, owner, inheritable, expirationTime);
584    
585                    return (Lock)newProxyInstance(lock, Lock.class);
586            }
587    
588            @Override
589            public FileEntry moveFileEntry(
590                            long fileEntryId, long newFolderId, ServiceContext serviceContext)
591                    throws PortalException {
592    
593                    FileEntry fileEntry = _baseRepository.moveFileEntry(
594                            fileEntryId, newFolderId, serviceContext);
595    
596                    return newFileEntryProxyBean(fileEntry);
597            }
598    
599            @Override
600            public Folder moveFolder(
601                            long folderId, long newParentFolderId,
602                            ServiceContext serviceContext)
603                    throws PortalException {
604    
605                    Folder folder = _baseRepository.moveFolder(
606                            folderId, newParentFolderId, serviceContext);
607    
608                    return newFolderProxyBean(folder);
609            }
610    
611            @Override
612            public Lock refreshFileEntryLock(
613                            String lockUuid, long companyId, long expirationTime)
614                    throws PortalException {
615    
616                    Lock lock = _baseRepository.refreshFileEntryLock(
617                            lockUuid, companyId, expirationTime);
618    
619                    return (Lock)newProxyInstance(lock, Lock.class);
620            }
621    
622            @Override
623            public Lock refreshFolderLock(
624                            String lockUuid, long companyId, long expirationTime)
625                    throws PortalException {
626    
627                    Lock lock = _baseRepository.refreshFolderLock(
628                            lockUuid, companyId, expirationTime);
629    
630                    return (Lock)newProxyInstance(lock, Lock.class);
631            }
632    
633            @Override
634            public void revertFileEntry(
635                            long fileEntryId, String version, ServiceContext serviceContext)
636                    throws PortalException {
637    
638                    _baseRepository.revertFileEntry(fileEntryId, version, serviceContext);
639            }
640    
641            @Override
642            public Hits search(long creatorUserId, int status, int start, int end)
643                    throws PortalException {
644    
645                    return _baseRepository.search(creatorUserId, status, start, end);
646            }
647    
648            @Override
649            public Hits search(
650                            long creatorUserId, long folderId, String[] mimeTypes, int status,
651                            int start, int end)
652                    throws PortalException {
653    
654                    return _baseRepository.search(
655                            creatorUserId, folderId, mimeTypes, status, start, end);
656            }
657    
658            @Override
659            public Hits search(SearchContext searchContext) throws SearchException {
660                    return _baseRepository.search(searchContext);
661            }
662    
663            @Override
664            public Hits search(SearchContext searchContext, Query query)
665                    throws SearchException {
666    
667                    return _baseRepository.search(searchContext, query);
668            }
669    
670            @Override
671            public void setAssetEntryLocalService(
672                    AssetEntryLocalService assetEntryLocalService) {
673    
674                    _baseRepository.setAssetEntryLocalService(assetEntryLocalService);
675            }
676    
677            @Override
678            public void setCompanyId(long companyId) {
679                    _baseRepository.setCompanyId(companyId);
680            }
681    
682            @Override
683            public void setCompanyLocalService(
684                    CompanyLocalService companyLocalService) {
685    
686                    _baseRepository.setCompanyLocalService(companyLocalService);
687            }
688    
689            @Override
690            public void setDLAppHelperLocalService(
691                    DLAppHelperLocalService dlAppHelperLocalService) {
692    
693                    _baseRepository.setDLAppHelperLocalService(dlAppHelperLocalService);
694            }
695    
696            @Override
697            public void setGroupId(long groupId) {
698                    _baseRepository.setGroupId(groupId);
699            }
700    
701            @Override
702            public void setRepositoryEntryLocalService(
703                    RepositoryEntryLocalService repositoryEntryLocalService) {
704    
705                    _baseRepository.setRepositoryEntryLocalService(
706                            repositoryEntryLocalService);
707            }
708    
709            @Override
710            public void setRepositoryId(long repositoryId) {
711                    _baseRepository.setRepositoryId(repositoryId);
712            }
713    
714            @Override
715            public void setTypeSettingsProperties(
716                    UnicodeProperties typeSettingsProperties) {
717    
718                    _baseRepository.setTypeSettingsProperties(typeSettingsProperties);
719            }
720    
721            @Override
722            public void setUserLocalService(UserLocalService userLocalService) {
723                    _baseRepository.setUserLocalService(userLocalService);
724            }
725    
726            @Override
727            public void unlockFolder(long folderId, String lockUuid)
728                    throws PortalException {
729    
730                    _baseRepository.unlockFolder(folderId, lockUuid);
731            }
732    
733            @Override
734            public void unlockFolder(long parentFolderId, String name, String lockUuid)
735                    throws PortalException {
736    
737                    _baseRepository.unlockFolder(parentFolderId, name, lockUuid);
738            }
739    
740            @Override
741            public FileEntry updateFileEntry(
742                            long fileEntryId, String sourceFileName, String mimeType,
743                            String title, String description, String changeLog,
744                            boolean majorVersion, File file, ServiceContext serviceContext)
745                    throws PortalException {
746    
747                    FileEntry fileEntry = _baseRepository.updateFileEntry(
748                            fileEntryId, sourceFileName, mimeType, title, description,
749                            changeLog, majorVersion, file, serviceContext);
750    
751                    return newFileEntryProxyBean(fileEntry);
752            }
753    
754            @Override
755            public FileEntry updateFileEntry(
756                            long fileEntryId, String sourceFileName, String mimeType,
757                            String title, String description, String changeLog,
758                            boolean majorVersion, InputStream is, long size,
759                            ServiceContext serviceContext)
760                    throws PortalException {
761    
762                    FileEntry fileEntry = _baseRepository.updateFileEntry(
763                            fileEntryId, sourceFileName, mimeType, title, description,
764                            changeLog, majorVersion, is, size, serviceContext);
765    
766                    return newFileEntryProxyBean(fileEntry);
767            }
768    
769            @Override
770            public Folder updateFolder(
771                            long folderId, String name, String description,
772                            ServiceContext serviceContext)
773                    throws PortalException {
774    
775                    Folder folder = _baseRepository.updateFolder(
776                            folderId, name, description, serviceContext);
777    
778                    return newFolderProxyBean(folder);
779            }
780    
781            @Override
782            public boolean verifyFileEntryCheckOut(long fileEntryId, String lockUuid)
783                    throws PortalException {
784    
785                    return _baseRepository.verifyFileEntryCheckOut(fileEntryId, lockUuid);
786            }
787    
788            @Override
789            public boolean verifyFileEntryLock(long fileEntryId, String lockUuid)
790                    throws PortalException {
791    
792                    return _baseRepository.verifyFileEntryLock(fileEntryId, lockUuid);
793            }
794    
795            @Override
796            public boolean verifyInheritableLock(long folderId, String lockUuid)
797                    throws PortalException {
798    
799                    return _baseRepository.verifyInheritableLock(folderId, lockUuid);
800            }
801    
802            private final BaseRepository _baseRepository;
803    
804    }