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 PortalException, 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)
266                    throws PortalException, SystemException {
267    
268                    return _baseRepository.getFileEntriesCount(folderId);
269            }
270    
271            @Override
272            public int getFileEntriesCount(long folderId, long documentTypeId)
273                    throws PortalException, SystemException {
274    
275                    return _baseRepository.getFileEntriesCount(folderId, documentTypeId);
276            }
277    
278            @Override
279            public int getFileEntriesCount(long folderId, String[] mimeTypes)
280                    throws PortalException, SystemException {
281    
282                    return _baseRepository.getFileEntriesCount(folderId, mimeTypes);
283            }
284    
285            @Override
286            public FileEntry getFileEntry(long fileEntryId)
287                    throws PortalException, SystemException {
288    
289                    FileEntry fileEntry = _baseRepository.getFileEntry(fileEntryId);
290    
291                    return newFileEntryProxyBean(fileEntry);
292            }
293    
294            @Override
295            public FileEntry getFileEntry(long folderId, String title)
296                    throws PortalException, SystemException {
297    
298                    FileEntry fileEntry = _baseRepository.getFileEntry(folderId, title);
299    
300                    return newFileEntryProxyBean(fileEntry);
301            }
302    
303            @Override
304            public FileEntry getFileEntryByUuid(String uuid)
305                    throws PortalException, SystemException {
306    
307                    FileEntry fileEntry = _baseRepository.getFileEntryByUuid(uuid);
308    
309                    return newFileEntryProxyBean(fileEntry);
310            }
311    
312            @Override
313            public FileVersion getFileVersion(long fileVersionId)
314                    throws PortalException, SystemException {
315    
316                    FileVersion fileVersion = _baseRepository.getFileVersion(fileVersionId);
317    
318                    return newFileVersionProxyBean(fileVersion);
319            }
320    
321            @Override
322            public Folder getFolder(long folderId)
323                    throws PortalException, SystemException {
324    
325                    Folder folder = _baseRepository.getFolder(folderId);
326    
327                    return newFolderProxyBean(folder);
328            }
329    
330            @Override
331            public Folder getFolder(long parentFolderId, String title)
332                    throws PortalException, SystemException {
333    
334                    Folder folder = _baseRepository.getFolder(parentFolderId, title);
335    
336                    return newFolderProxyBean(folder);
337            }
338    
339            @Override
340            public List<Folder> getFolders(
341                            long parentFolderId, boolean includeMountfolders, int start,
342                            int end, OrderByComparator obc)
343                    throws PortalException, SystemException {
344    
345                    List<Folder> folders = _baseRepository.getFolders(
346                            parentFolderId, includeMountfolders, start, end, obc);
347    
348                    return toFolderProxyBeans(folders);
349            }
350    
351            @Override
352            public List<Folder> getFolders(
353                            long parentFolderId, int status, boolean includeMountfolders,
354                            int start, int end, OrderByComparator obc)
355                    throws PortalException, SystemException {
356    
357                    List<Folder> folders = _baseRepository.getFolders(
358                            parentFolderId, status, includeMountfolders, start, end, obc);
359    
360                    return toFolderProxyBeans(folders);
361            }
362    
363            @Override
364            public List<Object> getFoldersAndFileEntriesAndFileShortcuts(
365                            long folderId, int status, boolean includeMountFolders, int start,
366                            int end, OrderByComparator obc)
367                    throws PortalException, SystemException {
368    
369                    List<Object> objects =
370                            _baseRepository.getFoldersAndFileEntriesAndFileShortcuts(
371                                    folderId, status, includeMountFolders, start, end, obc);
372    
373                    return toObjectProxyBeans(objects);
374            }
375    
376            @Override
377            public List<Object> getFoldersAndFileEntriesAndFileShortcuts(
378                            long folderId, int status, String[] mimeTypes,
379                            boolean includeMountFolders, int start, int end,
380                            OrderByComparator obc)
381                    throws PortalException, SystemException {
382    
383                    List<Object> objects =
384                            _baseRepository.getFoldersAndFileEntriesAndFileShortcuts(
385                                    folderId, status, mimeTypes, includeMountFolders, start, end,
386                                    obc);
387    
388                    return toObjectProxyBeans(objects);
389            }
390    
391            @Override
392            public int getFoldersAndFileEntriesAndFileShortcutsCount(
393                            long folderId, int status, boolean includeMountFolders)
394                    throws PortalException, SystemException {
395    
396                    return _baseRepository.getFoldersAndFileEntriesAndFileShortcutsCount(
397                            folderId, status, includeMountFolders);
398            }
399    
400            @Override
401            public int getFoldersAndFileEntriesAndFileShortcutsCount(
402                            long folderId, int status, String[] mimeTypes,
403                            boolean includeMountFolders)
404                    throws PortalException, SystemException {
405    
406                    return _baseRepository.getFoldersAndFileEntriesAndFileShortcutsCount(
407                            folderId, status, mimeTypes, includeMountFolders);
408            }
409    
410            @Override
411            public int getFoldersCount(long parentFolderId, boolean includeMountfolders)
412                    throws PortalException, SystemException {
413    
414                    return _baseRepository.getFoldersCount(
415                            parentFolderId, includeMountfolders);
416            }
417    
418            @Override
419            public int getFoldersCount(
420                            long parentFolderId, int status, boolean includeMountfolders)
421                    throws PortalException, SystemException {
422    
423                    return _baseRepository.getFoldersCount(
424                            parentFolderId, status, includeMountfolders);
425            }
426    
427            @Override
428            public int getFoldersFileEntriesCount(List<Long> folderIds, int status)
429                    throws PortalException, SystemException {
430    
431                    return _baseRepository.getFoldersFileEntriesCount(folderIds, status);
432            }
433    
434            @Override
435            public LocalRepository getLocalRepository() {
436                    LocalRepository localRepository = _baseRepository.getLocalRepository();
437    
438                    return newLocalRepositoryProxyBean(localRepository);
439            }
440    
441            @Override
442            public List<Folder> getMountFolders(
443                            long parentFolderId, int start, int end, OrderByComparator obc)
444                    throws PortalException, SystemException {
445    
446                    List<Folder> folders = _baseRepository.getMountFolders(
447                            parentFolderId, start, end, obc);
448    
449                    return toFolderProxyBeans(folders);
450            }
451    
452            @Override
453            public int getMountFoldersCount(long parentFolderId)
454                    throws PortalException, SystemException {
455    
456                    return _baseRepository.getMountFoldersCount(parentFolderId);
457            }
458    
459            public BaseRepository getProxyBean() {
460                    return _baseRepository;
461            }
462    
463            @Override
464            public List<FileEntry> getRepositoryFileEntries(
465                            long userId, long rootFolderId, int start, int end,
466                            OrderByComparator obc)
467                    throws PortalException, SystemException {
468    
469                    List<FileEntry> fileEntries = _baseRepository.getRepositoryFileEntries(
470                            userId, rootFolderId, start, end, obc);
471    
472                    return toFileEntryProxyBeans(fileEntries);
473            }
474    
475            @Override
476            public List<FileEntry> getRepositoryFileEntries(
477                            long userId, long rootFolderId, String[] mimeTypes, int status,
478                            int start, int end, OrderByComparator obc)
479                    throws PortalException, SystemException {
480    
481                    List<FileEntry> fileEntries = _baseRepository.getRepositoryFileEntries(
482                            userId, rootFolderId, mimeTypes, status, start, end, obc);
483    
484                    return toFileEntryProxyBeans(fileEntries);
485            }
486    
487            @Override
488            public int getRepositoryFileEntriesCount(long userId, long rootFolderId)
489                    throws PortalException, SystemException {
490    
491                    return _baseRepository.getRepositoryFileEntriesCount(
492                            userId, rootFolderId);
493            }
494    
495            @Override
496            public int getRepositoryFileEntriesCount(
497                            long userId, long rootFolderId, String[] mimeTypes, int status)
498                    throws PortalException, SystemException {
499    
500                    return _baseRepository.getRepositoryFileEntriesCount(
501                            userId, rootFolderId, mimeTypes, status);
502            }
503    
504            @Override
505            public long getRepositoryId() {
506                    return _baseRepository.getRepositoryId();
507            }
508    
509            @Override
510            public void getSubfolderIds(List<Long> folderIds, long folderId)
511                    throws PortalException, SystemException {
512    
513                    _baseRepository.getSubfolderIds(folderIds, folderId);
514            }
515    
516            @Override
517            public List<Long> getSubfolderIds(long folderId, boolean recurse)
518                    throws PortalException, SystemException {
519    
520                    return _baseRepository.getSubfolderIds(folderId, recurse);
521            }
522    
523            @Override
524            public String[] getSupportedConfigurations() {
525                    return _baseRepository.getSupportedConfigurations();
526            }
527    
528            @Override
529            public String[][] getSupportedParameters() {
530                    return _baseRepository.getSupportedParameters();
531            }
532    
533            @Override
534            public void initRepository() throws PortalException, SystemException {
535                    _baseRepository.initRepository();
536            }
537    
538            /**
539             * @deprecated As of 6.2.0, replaced by {@link #checkOutFileEntry(long,
540             *             ServiceContext)}
541             */
542            @Override
543            public Lock lockFileEntry(long fileEntryId)
544                    throws PortalException, SystemException {
545    
546                    Lock lock = _baseRepository.lockFileEntry(fileEntryId);
547    
548                    return (Lock)newProxyInstance(lock, Lock.class);
549            }
550    
551            /**
552             * @deprecated As of 6.2.0, replaced by {@link #checkOutFileEntry(long,
553             *             String, long, ServiceContext)}
554             */
555            @Override
556            public Lock lockFileEntry(
557                            long fileEntryId, String owner, long expirationTime)
558                    throws PortalException, SystemException {
559    
560                    Lock lock = _baseRepository.lockFileEntry(
561                            fileEntryId, owner, expirationTime);
562    
563                    return (Lock)newProxyInstance(lock, Lock.class);
564            }
565    
566            @Override
567            public Lock lockFolder(long folderId)
568                    throws PortalException, SystemException {
569    
570                    Lock lock = _baseRepository.lockFolder(folderId);
571    
572                    return (Lock)newProxyInstance(lock, Lock.class);
573            }
574    
575            @Override
576            public Lock lockFolder(
577                            long folderId, String owner, boolean inheritable,
578                            long expirationTime)
579                    throws PortalException, SystemException {
580    
581                    Lock lock = _baseRepository.lockFolder(
582                            folderId, owner, inheritable, expirationTime);
583    
584                    return (Lock)newProxyInstance(lock, Lock.class);
585            }
586    
587            @Override
588            public FileEntry moveFileEntry(
589                            long fileEntryId, long newFolderId, ServiceContext serviceContext)
590                    throws PortalException, SystemException {
591    
592                    FileEntry fileEntry = _baseRepository.moveFileEntry(
593                            fileEntryId, newFolderId, serviceContext);
594    
595                    return newFileEntryProxyBean(fileEntry);
596            }
597    
598            @Override
599            public Folder moveFolder(
600                            long folderId, long newParentFolderId,
601                            ServiceContext serviceContext)
602                    throws PortalException, SystemException {
603    
604                    Folder folder = _baseRepository.moveFolder(
605                            folderId, newParentFolderId, serviceContext);
606    
607                    return newFolderProxyBean(folder);
608            }
609    
610            @Override
611            public Lock refreshFileEntryLock(
612                            String lockUuid, long companyId, long expirationTime)
613                    throws PortalException, SystemException {
614    
615                    Lock lock = _baseRepository.refreshFileEntryLock(
616                            lockUuid, companyId, expirationTime);
617    
618                    return (Lock)newProxyInstance(lock, Lock.class);
619            }
620    
621            @Override
622            public Lock refreshFolderLock(
623                            String lockUuid, long companyId, long expirationTime)
624                    throws PortalException, SystemException {
625    
626                    Lock lock = _baseRepository.refreshFolderLock(
627                            lockUuid, companyId, expirationTime);
628    
629                    return (Lock)newProxyInstance(lock, Lock.class);
630            }
631    
632            @Override
633            public void revertFileEntry(
634                            long fileEntryId, String version, ServiceContext serviceContext)
635                    throws PortalException, SystemException {
636    
637                    _baseRepository.revertFileEntry(fileEntryId, version, serviceContext);
638            }
639    
640            @Override
641            public Hits search(long creatorUserId, int status, int start, int end)
642                    throws PortalException, SystemException {
643    
644                    return _baseRepository.search(creatorUserId, status, start, end);
645            }
646    
647            @Override
648            public Hits search(
649                            long creatorUserId, long folderId, String[] mimeTypes, int status,
650                            int start, int end)
651                    throws PortalException, SystemException {
652    
653                    return _baseRepository.search(
654                            creatorUserId, folderId, mimeTypes, status, start, end);
655            }
656    
657            @Override
658            public Hits search(SearchContext searchContext) throws SearchException {
659                    return _baseRepository.search(searchContext);
660            }
661    
662            @Override
663            public Hits search(SearchContext searchContext, Query query)
664                    throws SearchException {
665    
666                    return _baseRepository.search(searchContext, query);
667            }
668    
669            @Override
670            public void setAssetEntryLocalService(
671                    AssetEntryLocalService assetEntryLocalService) {
672    
673                    _baseRepository.setAssetEntryLocalService(assetEntryLocalService);
674            }
675    
676            @Override
677            public void setCompanyId(long companyId) {
678                    _baseRepository.setCompanyId(companyId);
679            }
680    
681            @Override
682            public void setCompanyLocalService(
683                    CompanyLocalService companyLocalService) {
684    
685                    _baseRepository.setCompanyLocalService(companyLocalService);
686            }
687    
688            @Override
689            public void setCounterLocalService(
690                    CounterLocalService counterLocalService) {
691    
692                    _baseRepository.setCounterLocalService(counterLocalService);
693            }
694    
695            @Override
696            public void setDLAppHelperLocalService(
697                    DLAppHelperLocalService dlAppHelperLocalService) {
698    
699                    _baseRepository.setDLAppHelperLocalService(dlAppHelperLocalService);
700            }
701    
702            @Override
703            public void setGroupId(long groupId) {
704                    _baseRepository.setGroupId(groupId);
705            }
706    
707            @Override
708            public void setRepositoryId(long repositoryId) {
709                    _baseRepository.setRepositoryId(repositoryId);
710            }
711    
712            @Override
713            public void setTypeSettingsProperties(
714                    UnicodeProperties typeSettingsProperties) {
715    
716                    _baseRepository.setTypeSettingsProperties(typeSettingsProperties);
717            }
718    
719            @Override
720            public void setUserLocalService(UserLocalService userLocalService) {
721                    _baseRepository.setUserLocalService(userLocalService);
722            }
723    
724            @Override
725            public void unlockFolder(long folderId, String lockUuid)
726                    throws PortalException, SystemException {
727    
728                    _baseRepository.unlockFolder(folderId, lockUuid);
729            }
730    
731            @Override
732            public void unlockFolder(long parentFolderId, String title, String lockUuid)
733                    throws PortalException, SystemException {
734    
735                    _baseRepository.unlockFolder(parentFolderId, title, lockUuid);
736            }
737    
738            @Override
739            public FileEntry updateFileEntry(
740                            long fileEntryId, String sourceFileName, String mimeType,
741                            String title, String description, String changeLog,
742                            boolean majorVersion, File file, ServiceContext serviceContext)
743                    throws PortalException, SystemException {
744    
745                    FileEntry fileEntry = _baseRepository.updateFileEntry(
746                            fileEntryId, sourceFileName, mimeType, title, description,
747                            changeLog, majorVersion, file, serviceContext);
748    
749                    return newFileEntryProxyBean(fileEntry);
750            }
751    
752            @Override
753            public FileEntry updateFileEntry(
754                            long fileEntryId, String sourceFileName, String mimeType,
755                            String title, String description, String changeLog,
756                            boolean majorVersion, InputStream is, long size,
757                            ServiceContext serviceContext)
758                    throws PortalException, SystemException {
759    
760                    FileEntry fileEntry = _baseRepository.updateFileEntry(
761                            fileEntryId, sourceFileName, mimeType, title, description,
762                            changeLog, majorVersion, is, size, serviceContext);
763    
764                    return newFileEntryProxyBean(fileEntry);
765            }
766    
767            @Override
768            public Folder updateFolder(
769                            long folderId, String title, String description,
770                            ServiceContext serviceContext)
771                    throws PortalException, SystemException {
772    
773                    Folder folder = _baseRepository.updateFolder(
774                            folderId, title, description, serviceContext);
775    
776                    return newFolderProxyBean(folder);
777            }
778    
779            @Override
780            public boolean verifyFileEntryCheckOut(long fileEntryId, String lockUuid)
781                    throws PortalException, SystemException {
782    
783                    return _baseRepository.verifyFileEntryCheckOut(fileEntryId, lockUuid);
784            }
785    
786            @Override
787            public boolean verifyFileEntryLock(long fileEntryId, String lockUuid)
788                    throws PortalException, SystemException {
789    
790                    return _baseRepository.verifyFileEntryLock(fileEntryId, lockUuid);
791            }
792    
793            @Override
794            public boolean verifyInheritableLock(long folderId, String lockUuid)
795                    throws PortalException, SystemException {
796    
797                    return _baseRepository.verifyInheritableLock(folderId, lockUuid);
798            }
799    
800            private BaseRepository _baseRepository;
801    
802    }