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