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.portlet.documentlibrary.service.impl;
016    
017    import com.liferay.document.library.kernel.exception.DuplicateFileEntryException;
018    import com.liferay.document.library.kernel.exception.DuplicateFolderNameException;
019    import com.liferay.document.library.kernel.exception.FolderNameException;
020    import com.liferay.document.library.kernel.exception.InvalidFolderException;
021    import com.liferay.document.library.kernel.exception.NoSuchFolderException;
022    import com.liferay.document.library.kernel.exception.RequiredFileEntryTypeException;
023    import com.liferay.document.library.kernel.model.DLFileEntry;
024    import com.liferay.document.library.kernel.model.DLFileEntryType;
025    import com.liferay.document.library.kernel.model.DLFileEntryTypeConstants;
026    import com.liferay.document.library.kernel.model.DLFolder;
027    import com.liferay.document.library.kernel.model.DLFolderConstants;
028    import com.liferay.document.library.kernel.store.DLStoreUtil;
029    import com.liferay.document.library.kernel.util.DLValidatorUtil;
030    import com.liferay.document.library.kernel.util.comparator.FolderIdComparator;
031    import com.liferay.exportimport.kernel.lar.ExportImportThreadLocal;
032    import com.liferay.portal.kernel.dao.orm.QueryDefinition;
033    import com.liferay.portal.kernel.dao.orm.QueryUtil;
034    import com.liferay.portal.kernel.exception.PortalException;
035    import com.liferay.portal.kernel.increment.BufferedIncrement;
036    import com.liferay.portal.kernel.increment.DateOverrideIncrement;
037    import com.liferay.portal.kernel.lock.ExpiredLockException;
038    import com.liferay.portal.kernel.lock.InvalidLockException;
039    import com.liferay.portal.kernel.lock.Lock;
040    import com.liferay.portal.kernel.lock.LockManagerUtil;
041    import com.liferay.portal.kernel.lock.NoSuchLockException;
042    import com.liferay.portal.kernel.log.Log;
043    import com.liferay.portal.kernel.log.LogFactoryUtil;
044    import com.liferay.portal.kernel.model.Group;
045    import com.liferay.portal.kernel.model.Repository;
046    import com.liferay.portal.kernel.model.ResourceConstants;
047    import com.liferay.portal.kernel.model.SystemEventConstants;
048    import com.liferay.portal.kernel.model.User;
049    import com.liferay.portal.kernel.model.WorkflowDefinitionLink;
050    import com.liferay.portal.kernel.repository.event.RepositoryEventTrigger;
051    import com.liferay.portal.kernel.repository.event.RepositoryEventType;
052    import com.liferay.portal.kernel.repository.model.Folder;
053    import com.liferay.portal.kernel.search.Indexable;
054    import com.liferay.portal.kernel.search.IndexableType;
055    import com.liferay.portal.kernel.search.Indexer;
056    import com.liferay.portal.kernel.search.IndexerRegistryUtil;
057    import com.liferay.portal.kernel.service.ServiceContext;
058    import com.liferay.portal.kernel.service.permission.ModelPermissions;
059    import com.liferay.portal.kernel.systemevent.SystemEvent;
060    import com.liferay.portal.kernel.tree.TreeModelTasksAdapter;
061    import com.liferay.portal.kernel.tree.TreePathUtil;
062    import com.liferay.portal.kernel.util.ObjectValuePair;
063    import com.liferay.portal.kernel.util.OrderByComparator;
064    import com.liferay.portal.kernel.util.ParamUtil;
065    import com.liferay.portal.kernel.util.StringPool;
066    import com.liferay.portal.kernel.util.Validator;
067    import com.liferay.portal.kernel.workflow.WorkflowConstants;
068    import com.liferay.portal.repository.liferayrepository.model.LiferayFolder;
069    import com.liferay.portal.util.RepositoryUtil;
070    import com.liferay.portlet.documentlibrary.model.impl.DLFolderImpl;
071    import com.liferay.portlet.documentlibrary.service.base.DLFolderLocalServiceBaseImpl;
072    
073    import java.io.Serializable;
074    
075    import java.util.ArrayList;
076    import java.util.Collections;
077    import java.util.Date;
078    import java.util.HashSet;
079    import java.util.List;
080    import java.util.Map;
081    import java.util.Set;
082    
083    /**
084     * @author Brian Wing Shun Chan
085     * @author Alexander Chow
086     */
087    public class DLFolderLocalServiceImpl extends DLFolderLocalServiceBaseImpl {
088    
089            @Override
090            public DLFolder addFolder(
091                            long userId, long groupId, long repositoryId, boolean mountPoint,
092                            long parentFolderId, String name, String description,
093                            boolean hidden, ServiceContext serviceContext)
094                    throws PortalException {
095    
096                    // Folder
097    
098                    User user = userPersistence.findByPrimaryKey(userId);
099                    parentFolderId = getParentFolderId(
100                            groupId, repositoryId, parentFolderId);
101                    Date now = new Date();
102    
103                    validateFolder(groupId, parentFolderId, name);
104    
105                    long folderId = counterLocalService.increment();
106    
107                    DLFolder dlFolder = dlFolderPersistence.create(folderId);
108    
109                    dlFolder.setUuid(serviceContext.getUuid());
110                    dlFolder.setGroupId(groupId);
111                    dlFolder.setCompanyId(user.getCompanyId());
112                    dlFolder.setUserId(user.getUserId());
113                    dlFolder.setUserName(user.getFullName());
114                    dlFolder.setRepositoryId(repositoryId);
115                    dlFolder.setMountPoint(mountPoint);
116                    dlFolder.setParentFolderId(parentFolderId);
117                    dlFolder.setTreePath(dlFolder.buildTreePath());
118                    dlFolder.setName(name);
119                    dlFolder.setDescription(description);
120                    dlFolder.setLastPostDate(now);
121                    dlFolder.setHidden(hidden);
122                    dlFolder.setRestrictionType(DLFolderConstants.RESTRICTION_TYPE_INHERIT);
123                    dlFolder.setExpandoBridgeAttributes(serviceContext);
124    
125                    dlFolderPersistence.update(dlFolder);
126    
127                    // Resources
128    
129                    if (serviceContext.isAddGroupPermissions() ||
130                            serviceContext.isAddGuestPermissions()) {
131    
132                            addFolderResources(
133                                    dlFolder, serviceContext.isAddGroupPermissions(),
134                                    serviceContext.isAddGuestPermissions());
135                    }
136                    else {
137                            if (serviceContext.isDeriveDefaultPermissions()) {
138                                    serviceContext.deriveDefaultPermissions(
139                                            repositoryId, DLFolderConstants.getClassName());
140                            }
141    
142                            addFolderResources(dlFolder, serviceContext.getModelPermissions());
143                    }
144    
145                    // Parent folder
146    
147                    if (parentFolderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
148                            dlFolderLocalService.updateLastPostDate(parentFolderId, now);
149                    }
150    
151                    return dlFolder;
152            }
153    
154            /**
155             * @deprecated As of 7.0.0, replaced by {@link #deleteAllByGroup(long)}
156             */
157            @Deprecated
158            @Override
159            public void deleteAll(long groupId) throws PortalException {
160                    deleteAllByGroup(groupId);
161            }
162    
163            @Override
164            public void deleteAllByGroup(long groupId) throws PortalException {
165                    Group group = groupLocalService.getGroup(groupId);
166    
167                    List<DLFolder> dlFolders = dlFolderPersistence.findByGroupId(groupId);
168    
169                    for (DLFolder dlFolder : dlFolders) {
170                            dlFolderLocalService.deleteFolder(dlFolder);
171                    }
172    
173                    dlFileEntryLocalService.deleteFileEntries(
174                            groupId, DLFolderConstants.DEFAULT_PARENT_FOLDER_ID);
175    
176                    dlFileEntryTypeLocalService.deleteFileEntryTypes(groupId);
177    
178                    dlFileShortcutLocalService.deleteFileShortcuts(
179                            groupId, DLFolderConstants.DEFAULT_PARENT_FOLDER_ID);
180    
181                    DLStoreUtil.deleteDirectory(
182                            group.getCompanyId(), groupId, StringPool.BLANK);
183            }
184    
185            @Override
186            public void deleteAllByRepository(long repositoryId)
187                    throws PortalException {
188    
189                    Repository repository = repositoryLocalService.fetchRepository(
190                            repositoryId);
191    
192                    long groupId = repositoryId;
193    
194                    if (repository != null) {
195                            groupId = repository.getGroupId();
196                    }
197    
198                    Group group = groupLocalService.getGroup(groupId);
199    
200                    RepositoryEventTrigger repositoryEventTrigger =
201                            RepositoryUtil.getRepositoryEventTrigger(repositoryId);
202    
203                    List<DLFolder> dlFolders = dlFolderPersistence.findByRepositoryId(
204                            repositoryId);
205    
206                    for (DLFolder dlFolder : dlFolders) {
207                            deleteFolderDependencies(dlFolder, true);
208    
209                            repositoryEventTrigger.trigger(
210                                    RepositoryEventType.Delete.class, Folder.class,
211                                    new LiferayFolder(dlFolder));
212                    }
213    
214                    if (repository != null) {
215                            dlFileEntryLocalService.deleteRepositoryFileEntries(
216                                    repository.getRepositoryId(), repository.getDlFolderId());
217                    }
218                    else {
219                            dlFileEntryLocalService.deleteFileEntries(
220                                    groupId, DLFolderConstants.DEFAULT_PARENT_FOLDER_ID);
221    
222                            dlFileShortcutLocalService.deleteFileShortcuts(
223                                    groupId, DLFolderConstants.DEFAULT_PARENT_FOLDER_ID);
224                    }
225    
226                    DLStoreUtil.deleteDirectory(
227                            group.getCompanyId(), repositoryId, StringPool.BLANK);
228            }
229    
230            @Indexable(type = IndexableType.DELETE)
231            @Override
232            @SystemEvent(
233                    action = SystemEventConstants.ACTION_SKIP,
234                    type = SystemEventConstants.TYPE_DELETE
235            )
236            public DLFolder deleteFolder(DLFolder dlFolder) throws PortalException {
237                    return deleteFolder(dlFolder, true);
238            }
239    
240            @Indexable(type = IndexableType.DELETE)
241            @Override
242            @SystemEvent(
243                    action = SystemEventConstants.ACTION_SKIP,
244                    type = SystemEventConstants.TYPE_DELETE
245            )
246            public DLFolder deleteFolder(
247                            DLFolder dlFolder, boolean includeTrashedEntries)
248                    throws PortalException {
249    
250                    deleteSubfolders(dlFolder, includeTrashedEntries);
251    
252                    deleteFolderDependencies(dlFolder, includeTrashedEntries);
253    
254                    return dlFolder;
255            }
256    
257            @Indexable(type = IndexableType.DELETE)
258            @Override
259            public DLFolder deleteFolder(long folderId) throws PortalException {
260                    return dlFolderLocalService.deleteFolder(folderId, true);
261            }
262    
263            @Indexable(type = IndexableType.DELETE)
264            @Override
265            public DLFolder deleteFolder(long folderId, boolean includeTrashedEntries)
266                    throws PortalException {
267    
268                    DLFolder dlFolder = dlFolderPersistence.findByPrimaryKey(folderId);
269    
270                    return dlFolderLocalService.deleteFolder(
271                            dlFolder, includeTrashedEntries);
272            }
273    
274            @Indexable(type = IndexableType.DELETE)
275            @Override
276            public DLFolder deleteFolder(
277                            long userId, long folderId, boolean includeTrashedEntries)
278                    throws PortalException {
279    
280                    boolean hasLock = hasFolderLock(userId, folderId);
281    
282                    Lock lock = null;
283    
284                    if (!hasLock) {
285    
286                            // Lock
287    
288                            lock = lockFolder(
289                                    userId, folderId, null, false,
290                                    DLFolderImpl.LOCK_EXPIRATION_TIME);
291                    }
292    
293                    try {
294                            return deleteFolder(folderId, includeTrashedEntries);
295                    }
296                    finally {
297                            if (!hasLock) {
298    
299                                    // Unlock
300    
301                                    unlockFolder(folderId, lock.getUuid());
302                            }
303                    }
304            }
305    
306            @Override
307            public DLFolder fetchFolder(long folderId) {
308                    return dlFolderPersistence.fetchByPrimaryKey(folderId);
309            }
310    
311            @Override
312            public DLFolder fetchFolder(
313                    long groupId, long parentFolderId, String name) {
314    
315                    return dlFolderPersistence.fetchByG_P_N(groupId, parentFolderId, name);
316            }
317    
318            @Override
319            public List<DLFolder> getCompanyFolders(
320                    long companyId, int start, int end) {
321    
322                    return dlFolderPersistence.findByCompanyId(companyId, start, end);
323            }
324    
325            @Override
326            public int getCompanyFoldersCount(long companyId) {
327                    return dlFolderPersistence.countByCompanyId(companyId);
328            }
329    
330            @Override
331            public List<Object> getFileEntriesAndFileShortcuts(
332                    long groupId, long folderId, QueryDefinition<?> queryDefinition) {
333    
334                    return dlFolderFinder.findFE_FS_ByG_F(
335                            groupId, folderId, queryDefinition);
336            }
337    
338            @Override
339            public int getFileEntriesAndFileShortcutsCount(
340                    long groupId, long folderId, QueryDefinition<?> queryDefinition) {
341    
342                    return dlFolderFinder.countFE_FS_ByG_F(
343                            groupId, folderId, queryDefinition);
344            }
345    
346            @Override
347            public DLFolder getFolder(long folderId) throws PortalException {
348                    return dlFolderPersistence.findByPrimaryKey(folderId);
349            }
350    
351            @Override
352            public DLFolder getFolder(long groupId, long parentFolderId, String name)
353                    throws PortalException {
354    
355                    return dlFolderPersistence.findByG_P_N(groupId, parentFolderId, name);
356            }
357    
358            @Override
359            public long getFolderId(long companyId, long folderId) {
360                    if (folderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
361    
362                            // Ensure folder exists and belongs to the proper company
363    
364                            DLFolder dlFolder = dlFolderPersistence.fetchByPrimaryKey(folderId);
365    
366                            if ((dlFolder == null) || (companyId != dlFolder.getCompanyId())) {
367                                    folderId = DLFolderConstants.DEFAULT_PARENT_FOLDER_ID;
368                            }
369                    }
370    
371                    return folderId;
372            }
373    
374            /**
375             * @deprecated As of 7.0.0, replaced by {@link #getGroupFolderIds(long,
376             *             long)}
377             */
378            @Deprecated
379            @Override
380            public List<Long> getFolderIds(long groupId, long parentFolderId) {
381                    return getGroupFolderIds(groupId, parentFolderId);
382            }
383    
384            @Override
385            public List<DLFolder> getFolders(long groupId, long parentFolderId) {
386                    return getFolders(groupId, parentFolderId, true);
387            }
388    
389            @Override
390            public List<DLFolder> getFolders(
391                    long groupId, long parentFolderId, boolean includeMountfolders) {
392    
393                    if (includeMountfolders) {
394                            return dlFolderPersistence.findByG_P(groupId, parentFolderId);
395                    }
396                    else {
397                            return dlFolderPersistence.findByG_M_P_H(
398                                    groupId, false, parentFolderId, false);
399                    }
400            }
401    
402            @Override
403            public List<DLFolder> getFolders(
404                    long groupId, long parentFolderId, boolean includeMountfolders,
405                    int start, int end, OrderByComparator<DLFolder> obc) {
406    
407                    if (includeMountfolders) {
408                            return dlFolderPersistence.findByG_P(
409                                    groupId, parentFolderId, start, end, obc);
410                    }
411                    else {
412                            return dlFolderPersistence.findByG_M_P_H(
413                                    groupId, false, parentFolderId, false, start, end, obc);
414                    }
415            }
416    
417            @Override
418            public List<DLFolder> getFolders(
419                    long groupId, long parentFolderId, int status,
420                    boolean includeMountfolders, int start, int end,
421                    OrderByComparator<DLFolder> obc) {
422    
423                    if (includeMountfolders) {
424                            return dlFolderPersistence.findByG_P_H_S(
425                                    groupId, parentFolderId, false, status, start, end, obc);
426                    }
427                    else {
428                            return dlFolderPersistence.findByG_M_P_H_S(
429                                    groupId, false, parentFolderId, false, status, start, end, obc);
430                    }
431            }
432    
433            @Override
434            public List<DLFolder> getFolders(
435                    long groupId, long parentFolderId, int start, int end,
436                    OrderByComparator<DLFolder> obc) {
437    
438                    return getFolders(groupId, parentFolderId, true, start, end, obc);
439            }
440    
441            @Override
442            public List<Object> getFoldersAndFileEntriesAndFileShortcuts(
443                    long groupId, long folderId, String[] mimeTypes,
444                    boolean includeMountFolders, QueryDefinition<?> queryDefinition) {
445    
446                    return dlFolderFinder.findF_FE_FS_ByG_F_M_M(
447                            groupId, folderId, mimeTypes, includeMountFolders, queryDefinition);
448            }
449    
450            @Override
451            public int getFoldersAndFileEntriesAndFileShortcutsCount(
452                    long groupId, long folderId, String[] mimeTypes,
453                    boolean includeMountFolders, QueryDefinition<?> queryDefinition) {
454    
455                    return dlFolderFinder.countF_FE_FS_ByG_F_M_M(
456                            groupId, folderId, mimeTypes, includeMountFolders, queryDefinition);
457            }
458    
459            @Override
460            public int getFoldersCount(long groupId, long parentFolderId) {
461                    return getFoldersCount(groupId, parentFolderId, true);
462            }
463    
464            @Override
465            public int getFoldersCount(
466                    long groupId, long parentFolderId, boolean includeMountfolders) {
467    
468                    if (includeMountfolders) {
469                            return dlFolderPersistence.countByG_P(groupId, parentFolderId);
470                    }
471                    else {
472                            return dlFolderPersistence.countByG_M_P_H(
473                                    groupId, false, parentFolderId, false);
474                    }
475            }
476    
477            @Override
478            public int getFoldersCount(
479                    long groupId, long parentFolderId, int status,
480                    boolean includeMountfolders) {
481    
482                    if (status == WorkflowConstants.STATUS_ANY) {
483                            return getFoldersCount(
484                                    groupId, parentFolderId, includeMountfolders);
485                    }
486                    else if (includeMountfolders) {
487                            return dlFolderPersistence.countByG_P_H_S(
488                                    groupId, parentFolderId, false, status);
489                    }
490                    else {
491                            return dlFolderPersistence.countByG_M_P_H_S(
492                                    groupId, false, parentFolderId, false, status);
493                    }
494            }
495    
496            @Override
497            public List<Long> getGroupFolderIds(long groupId, long parentFolderId) {
498                    List<Long> folderIds = new ArrayList<>();
499    
500                    folderIds.add(parentFolderId);
501    
502                    getGroupSubfolderIds(folderIds, groupId, parentFolderId);
503    
504                    return folderIds;
505            }
506    
507            @Override
508            public void getGroupSubfolderIds(
509                    List<Long> folderIds, long groupId, long folderId) {
510    
511                    List<DLFolder> dlFolders = dlFolderPersistence.findByG_P(
512                            groupId, folderId);
513    
514                    for (DLFolder dlFolder : dlFolders) {
515                            folderIds.add(dlFolder.getFolderId());
516    
517                            getGroupSubfolderIds(
518                                    folderIds, dlFolder.getGroupId(), dlFolder.getFolderId());
519                    }
520            }
521    
522            @Override
523            public DLFolder getMountFolder(long repositoryId) throws PortalException {
524                    return dlFolderPersistence.findByR_M(repositoryId, true);
525            }
526    
527            @Override
528            public List<DLFolder> getMountFolders(
529                    long groupId, long parentFolderId, int start, int end,
530                    OrderByComparator<DLFolder> obc) {
531    
532                    return dlFolderPersistence.findByG_M_P_H(
533                            groupId, true, parentFolderId, false, start, end, obc);
534            }
535    
536            @Override
537            public int getMountFoldersCount(long groupId, long parentFolderId) {
538                    return dlFolderPersistence.countByG_M_P_H(
539                            groupId, true, parentFolderId, false);
540            }
541    
542            @Override
543            public List<DLFolder> getNoAssetFolders() {
544                    return dlFolderFinder.findF_ByNoAssets();
545            }
546    
547            @Override
548            public List<Long> getRepositoryFolderIds(
549                    long repositoryId, long parentFolderId) {
550    
551                    List<Long> folderIds = new ArrayList<>();
552    
553                    folderIds.add(parentFolderId);
554    
555                    getRepositorySubfolderIds(folderIds, repositoryId, parentFolderId);
556    
557                    return folderIds;
558            }
559    
560            @Override
561            public List<DLFolder> getRepositoryFolders(
562                    long repositoryId, int start, int end) {
563    
564                    return dlFolderPersistence.findByRepositoryId(repositoryId, start, end);
565            }
566    
567            @Override
568            public int getRepositoryFoldersCount(long repositoryId) {
569                    return dlFolderPersistence.countByRepositoryId(repositoryId);
570            }
571    
572            @Override
573            public void getRepositorySubfolderIds(
574                    List<Long> folderIds, long repositoryId, long folderId) {
575    
576                    List<DLFolder> dlFolders = dlFolderPersistence.findByR_P(
577                            repositoryId, folderId);
578    
579                    for (DLFolder dlFolder : dlFolders) {
580                            folderIds.add(dlFolder.getFolderId());
581    
582                            getRepositorySubfolderIds(
583                                    folderIds, dlFolder.getRepositoryId(), dlFolder.getFolderId());
584                    }
585            }
586    
587            /**
588             * @deprecated As of 7.0.0, replaced by {@link #getGroupSubfolderIds(List,
589             *             long, long)}
590             */
591            @Deprecated
592            @Override
593            public void getSubfolderIds(
594                    List<Long> folderIds, long groupId, long folderId) {
595    
596                    getGroupSubfolderIds(folderIds, groupId, folderId);
597            }
598    
599            @Override
600            public boolean hasFolderLock(long userId, long folderId) {
601                    return LockManagerUtil.hasLock(
602                            userId, DLFolder.class.getName(), folderId);
603            }
604    
605            @Override
606            public boolean hasInheritableLock(long folderId) throws PortalException {
607                    boolean inheritable = false;
608    
609                    try {
610                            Lock lock = LockManagerUtil.getLock(
611                                    DLFolder.class.getName(), folderId);
612    
613                            inheritable = lock.isInheritable();
614                    }
615                    catch (ExpiredLockException ele) {
616                            if (_log.isDebugEnabled()) {
617                                    _log.debug(ele, ele);
618                            }
619                    }
620                    catch (NoSuchLockException nsle) {
621                            if (_log.isDebugEnabled()) {
622                                    _log.debug(nsle, nsle);
623                            }
624                    }
625    
626                    return inheritable;
627            }
628    
629            @Override
630            public Lock lockFolder(long userId, long folderId) throws PortalException {
631                    return lockFolder(
632                            userId, folderId, null, false, DLFolderImpl.LOCK_EXPIRATION_TIME);
633            }
634    
635            @Override
636            public Lock lockFolder(
637                            long userId, long folderId, String owner, boolean inheritable,
638                            long expirationTime)
639                    throws PortalException {
640    
641                    if ((expirationTime <= 0) ||
642                            (expirationTime > DLFolderImpl.LOCK_EXPIRATION_TIME)) {
643    
644                            expirationTime = DLFolderImpl.LOCK_EXPIRATION_TIME;
645                    }
646    
647                    return LockManagerUtil.lock(
648                            userId, DLFolder.class.getName(), folderId, owner, inheritable,
649                            expirationTime);
650            }
651    
652            @Indexable(type = IndexableType.REINDEX)
653            @Override
654            public DLFolder moveFolder(
655                            long userId, long folderId, long parentFolderId,
656                            ServiceContext serviceContext)
657                    throws PortalException {
658    
659                    DLFolder dlFolder = dlFolderPersistence.findByPrimaryKey(folderId);
660    
661                    parentFolderId = getParentFolderId(dlFolder, parentFolderId);
662    
663                    if (dlFolder.getParentFolderId() == parentFolderId) {
664                            return dlFolder;
665                    }
666    
667                    boolean hasLock = hasFolderLock(userId, folderId);
668    
669                    Lock lock = null;
670    
671                    if (!hasLock) {
672    
673                            // Lock
674    
675                            lock = lockFolder(userId, folderId);
676                    }
677    
678                    try {
679                            validateFolder(
680                                    dlFolder.getFolderId(), dlFolder.getGroupId(), parentFolderId,
681                                    dlFolder.getName());
682    
683                            dlFolder.setParentFolderId(parentFolderId);
684                            dlFolder.setTreePath(dlFolder.buildTreePath());
685                            dlFolder.setExpandoBridgeAttributes(serviceContext);
686    
687                            dlFolderPersistence.update(dlFolder);
688    
689                            rebuildTree(
690                                    dlFolder.getCompanyId(), folderId, dlFolder.getTreePath(),
691                                    true);
692    
693                            return dlFolder;
694                    }
695                    finally {
696                            if (!hasLock) {
697    
698                                    // Unlock
699    
700                                    unlockFolder(folderId, lock.getUuid());
701                            }
702                    }
703            }
704    
705            @Override
706            public void rebuildTree(long companyId) throws PortalException {
707                    rebuildTree(
708                            companyId, DLFolderConstants.DEFAULT_PARENT_FOLDER_ID,
709                            StringPool.SLASH, false);
710            }
711    
712            @Override
713            public void rebuildTree(
714                            long companyId, long parentFolderId, String parentTreePath,
715                            final boolean reindex)
716                    throws PortalException {
717    
718                    TreePathUtil.rebuildTree(
719                            companyId, parentFolderId, parentTreePath,
720                            new TreeModelTasksAdapter<DLFolder>() {
721    
722                                    @Override
723                                    public List<DLFolder> findTreeModels(
724                                            long previousId, long companyId, long parentPrimaryKey,
725                                            int size) {
726    
727                                            return dlFolderPersistence.findByF_C_P_NotS(
728                                                    previousId, companyId, parentPrimaryKey,
729                                                    WorkflowConstants.STATUS_IN_TRASH, QueryUtil.ALL_POS,
730                                                    size, new FolderIdComparator(true));
731                                    }
732    
733                                    @Override
734                                    public void rebuildDependentModelsTreePaths(
735                                                    long parentPrimaryKey, String treePath)
736                                            throws PortalException {
737    
738                                            dlFileEntryLocalService.setTreePaths(
739                                                    parentPrimaryKey, treePath, false);
740                                            dlFileShortcutLocalService.setTreePaths(
741                                                    parentPrimaryKey, treePath);
742                                            dlFileVersionLocalService.setTreePaths(
743                                                    parentPrimaryKey, treePath);
744                                    }
745    
746                            });
747            }
748    
749            @Override
750            public void unlockFolder(
751                            long groupId, long parentFolderId, String name, String lockUuid)
752                    throws PortalException {
753    
754                    DLFolder dlFolder = getFolder(groupId, parentFolderId, name);
755    
756                    unlockFolder(dlFolder.getFolderId(), lockUuid);
757            }
758    
759            @Override
760            public void unlockFolder(long folderId, String lockUuid)
761                    throws PortalException {
762    
763                    if (Validator.isNotNull(lockUuid)) {
764                            try {
765                                    Lock lock = LockManagerUtil.getLock(
766                                            DLFolder.class.getName(), folderId);
767    
768                                    if (!lockUuid.equals(lock.getUuid())) {
769                                            throw new InvalidLockException("UUIDs do not match");
770                                    }
771                            }
772                            catch (ExpiredLockException | NoSuchLockException e) {
773                            }
774                    }
775    
776                    LockManagerUtil.unlock(DLFolder.class.getName(), folderId);
777            }
778    
779            /**
780             * @deprecated As of 7.0.0, replaced by {@link #updateFolder(long, long,
781             *             String, String, long, List, int, ServiceContext)}
782             */
783            @Deprecated
784            @Override
785            public DLFolder updateFolder(
786                            long folderId, long parentFolderId, String name, String description,
787                            long defaultFileEntryTypeId, List<Long> fileEntryTypeIds,
788                            boolean overrideFileEntryTypes, ServiceContext serviceContext)
789                    throws PortalException {
790    
791                    int restrictionType = DLFolderConstants.RESTRICTION_TYPE_INHERIT;
792    
793                    if (overrideFileEntryTypes) {
794                            restrictionType =
795                                    DLFolderConstants.
796                                            RESTRICTION_TYPE_FILE_ENTRY_TYPES_AND_WORKFLOW;
797                    }
798    
799                    return updateFolder(
800                            folderId, name, description, defaultFileEntryTypeId,
801                            fileEntryTypeIds, restrictionType, serviceContext);
802            }
803    
804            @Indexable(type = IndexableType.REINDEX)
805            @Override
806            public DLFolder updateFolder(
807                            long folderId, long parentFolderId, String name, String description,
808                            long defaultFileEntryTypeId, List<Long> fileEntryTypeIds,
809                            int restrictionType, ServiceContext serviceContext)
810                    throws PortalException {
811    
812                    boolean hasLock = hasFolderLock(serviceContext.getUserId(), folderId);
813    
814                    Lock lock = null;
815    
816                    if (!hasLock) {
817    
818                            // Lock
819    
820                            lock = lockFolder(
821                                    serviceContext.getUserId(), folderId, null, false,
822                                    DLFolderImpl.LOCK_EXPIRATION_TIME);
823                    }
824    
825                    try {
826    
827                            // File entry types
828    
829                            DLFolder dlFolder = null;
830    
831                            Set<Long> originalFileEntryTypeIds = new HashSet<>();
832    
833                            if (folderId > DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
834                                    originalFileEntryTypeIds = getFileEntryTypeIds(
835                                            dlFolderPersistence.getDLFileEntryTypes(folderId));
836    
837                                    dlFolder = dlFolderLocalService.updateFolderAndFileEntryTypes(
838                                            serviceContext.getUserId(), folderId, parentFolderId, name,
839                                            description, defaultFileEntryTypeId, fileEntryTypeIds,
840                                            restrictionType, serviceContext);
841    
842                                    if (!ExportImportThreadLocal.isImportInProcess()) {
843                                            dlFileEntryTypeLocalService.cascadeFileEntryTypes(
844                                                    serviceContext.getUserId(), dlFolder);
845                                    }
846                            }
847    
848                            // Workflow definitions
849    
850                            List<ObjectValuePair<Long, String>> workflowDefinitionOVPs =
851                                    new ArrayList<>();
852    
853                            if (restrictionType ==
854                                            DLFolderConstants.
855                                                    RESTRICTION_TYPE_FILE_ENTRY_TYPES_AND_WORKFLOW) {
856    
857                                    workflowDefinitionOVPs.add(
858                                            new ObjectValuePair<Long, String>(
859                                                    DLFileEntryTypeConstants.FILE_ENTRY_TYPE_ID_ALL,
860                                                    StringPool.BLANK));
861    
862                                    for (long fileEntryTypeId : fileEntryTypeIds) {
863                                            String workflowDefinition = ParamUtil.getString(
864                                                    serviceContext, "workflowDefinition" + fileEntryTypeId);
865    
866                                            workflowDefinitionOVPs.add(
867                                                    new ObjectValuePair<Long, String>(
868                                                            fileEntryTypeId, workflowDefinition));
869                                    }
870                            }
871                            else if (restrictionType ==
872                                                    DLFolderConstants.RESTRICTION_TYPE_INHERIT) {
873    
874                                    if (originalFileEntryTypeIds.isEmpty()) {
875                                            originalFileEntryTypeIds.add(
876                                                    DLFileEntryTypeConstants.FILE_ENTRY_TYPE_ID_ALL);
877                                    }
878    
879                                    for (long originalFileEntryTypeId : originalFileEntryTypeIds) {
880                                            workflowDefinitionOVPs.add(
881                                                    new ObjectValuePair<Long, String>(
882                                                            originalFileEntryTypeId, StringPool.BLANK));
883                                    }
884                            }
885                            else if (restrictionType ==
886                                                    DLFolderConstants.RESTRICTION_TYPE_WORKFLOW) {
887    
888                                    String workflowDefinition = ParamUtil.getString(
889                                            serviceContext,
890                                            "workflowDefinition" +
891                                                    DLFileEntryTypeConstants.FILE_ENTRY_TYPE_ID_ALL);
892    
893                                    workflowDefinitionOVPs.add(
894                                            new ObjectValuePair<Long, String>(
895                                                    DLFileEntryTypeConstants.FILE_ENTRY_TYPE_ID_ALL,
896                                                    workflowDefinition));
897    
898                                    for (long originalFileEntryTypeId : originalFileEntryTypeIds) {
899                                            workflowDefinitionOVPs.add(
900                                                    new ObjectValuePair<Long, String>(
901                                                            originalFileEntryTypeId, StringPool.BLANK));
902                                    }
903                            }
904    
905                            workflowDefinitionLinkLocalService.updateWorkflowDefinitionLinks(
906                                    serviceContext.getUserId(), serviceContext.getCompanyId(),
907                                    serviceContext.getScopeGroupId(), DLFolder.class.getName(),
908                                    folderId, workflowDefinitionOVPs);
909    
910                            return dlFolder;
911                    }
912                    finally {
913                            if (!hasLock) {
914    
915                                    // Unlock
916    
917                                    unlockFolder(folderId, lock.getUuid());
918                            }
919                    }
920            }
921    
922            /**
923             * @deprecated As of 7.0.0, replaced {@link #updateFolder(long, long,
924             *             String, String, long, List, int, ServiceContext)}
925             */
926            @Deprecated
927            @Override
928            public DLFolder updateFolder(
929                            long folderId, String name, String description,
930                            long defaultFileEntryTypeId, List<Long> fileEntryTypeIds,
931                            boolean overrideFileEntryTypes, ServiceContext serviceContext)
932                    throws PortalException {
933    
934                    int restrictionType = DLFolderConstants.RESTRICTION_TYPE_INHERIT;
935    
936                    if (overrideFileEntryTypes) {
937                            restrictionType =
938                                    DLFolderConstants.
939                                            RESTRICTION_TYPE_FILE_ENTRY_TYPES_AND_WORKFLOW;
940                    }
941    
942                    return updateFolder(
943                            serviceContext.getScopeGroupId(), folderId, name, description,
944                            defaultFileEntryTypeId, fileEntryTypeIds, restrictionType,
945                            serviceContext);
946            }
947    
948            @Indexable(type = IndexableType.REINDEX)
949            @Override
950            public DLFolder updateFolder(
951                            long folderId, String name, String description,
952                            long defaultFileEntryTypeId, List<Long> fileEntryTypeIds,
953                            int restrictionType, ServiceContext serviceContext)
954                    throws PortalException {
955    
956                    long parentFolderId = DLFolderConstants.DEFAULT_PARENT_FOLDER_ID;
957    
958                    if (folderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
959                            DLFolder dlFolder = getDLFolder(folderId);
960    
961                            parentFolderId = dlFolder.getParentFolderId();
962                    }
963    
964                    return updateFolder(
965                            folderId, parentFolderId, name, description, defaultFileEntryTypeId,
966                            fileEntryTypeIds, restrictionType, serviceContext);
967            }
968    
969            /**
970             * @deprecated As of 7.0.0, replaced by {@link #
971             *             updateFolderAndFileEntryTypes(long, long, long, String,
972             *             String, long, List, int, ServiceContext)}
973             */
974            @Deprecated
975            @Override
976            public DLFolder updateFolderAndFileEntryTypes(
977                            long userId, long folderId, long parentFolderId, String name,
978                            String description, long defaultFileEntryTypeId,
979                            List<Long> fileEntryTypeIds, boolean overrideFileEntryTypes,
980                            ServiceContext serviceContext)
981                    throws PortalException {
982    
983                    int restrictionType = DLFolderConstants.RESTRICTION_TYPE_INHERIT;
984    
985                    if (overrideFileEntryTypes) {
986                            restrictionType =
987                                    DLFolderConstants.
988                                            RESTRICTION_TYPE_FILE_ENTRY_TYPES_AND_WORKFLOW;
989                    }
990    
991                    return updateFolderAndFileEntryTypes(
992                            userId, folderId, parentFolderId, name, description,
993                            defaultFileEntryTypeId, fileEntryTypeIds, restrictionType,
994                            serviceContext);
995            }
996    
997            @Override
998            public DLFolder updateFolderAndFileEntryTypes(
999                            long userId, long folderId, long parentFolderId, String name,
1000                            String description, long defaultFileEntryTypeId,
1001                            List<Long> fileEntryTypeIds, int restrictionType,
1002                            ServiceContext serviceContext)
1003                    throws PortalException {
1004    
1005                    if ((restrictionType ==
1006                                    DLFolderConstants.
1007                                            RESTRICTION_TYPE_FILE_ENTRY_TYPES_AND_WORKFLOW) &&
1008                            fileEntryTypeIds.isEmpty()) {
1009    
1010                            throw new RequiredFileEntryTypeException(
1011                                    "File entry type IDs is empty");
1012                    }
1013    
1014                    boolean hasLock = hasFolderLock(userId, folderId);
1015    
1016                    Lock lock = null;
1017    
1018                    if (!hasLock) {
1019    
1020                            // Lock
1021    
1022                            lock = lockFolder(
1023                                    userId, folderId, null, false,
1024                                    DLFolderImpl.LOCK_EXPIRATION_TIME);
1025                    }
1026    
1027                    try {
1028    
1029                            // Folder
1030    
1031                            if (restrictionType == DLFolderConstants.RESTRICTION_TYPE_INHERIT) {
1032                                    fileEntryTypeIds = Collections.emptyList();
1033                            }
1034    
1035                            DLFolder dlFolder = dlFolderPersistence.findByPrimaryKey(folderId);
1036    
1037                            parentFolderId = getParentFolderId(dlFolder, parentFolderId);
1038    
1039                            validateFolder(
1040                                    folderId, dlFolder.getGroupId(), parentFolderId, name);
1041    
1042                            long oldParentFolderId = dlFolder.getParentFolderId();
1043    
1044                            if (oldParentFolderId != parentFolderId) {
1045                                    dlFolder.setParentFolderId(parentFolderId);
1046                                    dlFolder.setTreePath(dlFolder.buildTreePath());
1047                            }
1048    
1049                            dlFolder.setName(name);
1050                            dlFolder.setDescription(description);
1051                            dlFolder.setExpandoBridgeAttributes(serviceContext);
1052                            dlFolder.setRestrictionType(restrictionType);
1053                            dlFolder.setDefaultFileEntryTypeId(defaultFileEntryTypeId);
1054    
1055                            dlFolderPersistence.update(dlFolder);
1056    
1057                            // File entry types
1058    
1059                            if (fileEntryTypeIds != null) {
1060                                    dlFileEntryTypeLocalService.updateFolderFileEntryTypes(
1061                                            dlFolder, fileEntryTypeIds, defaultFileEntryTypeId,
1062                                            serviceContext);
1063                            }
1064    
1065                            if (oldParentFolderId != parentFolderId) {
1066                                    rebuildTree(
1067                                            dlFolder.getCompanyId(), folderId, dlFolder.getTreePath(),
1068                                            true);
1069                            }
1070    
1071                            return dlFolder;
1072                    }
1073                    finally {
1074                            if (!hasLock) {
1075    
1076                                    // Unlock
1077    
1078                                    unlockFolder(folderId, lock.getUuid());
1079                            }
1080                    }
1081            }
1082    
1083            @BufferedIncrement(
1084                    configuration = "DLFolderEntry",
1085                    incrementClass = DateOverrideIncrement.class
1086            )
1087            @Override
1088            public void updateLastPostDate(long folderId, Date lastPostDate)
1089                    throws PortalException {
1090    
1091                    if (ExportImportThreadLocal.isImportInProcess() ||
1092                            (folderId == DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) ||
1093                            (lastPostDate == null)) {
1094    
1095                            return;
1096                    }
1097    
1098                    DLFolder dlFolder = dlFolderPersistence.findByPrimaryKey(folderId);
1099    
1100                    if (lastPostDate.before(dlFolder.getLastPostDate())) {
1101                            return;
1102                    }
1103    
1104                    dlFolder.setModifiedDate(dlFolder.getModifiedDate());
1105                    dlFolder.setLastPostDate(lastPostDate);
1106    
1107                    dlFolderPersistence.update(dlFolder);
1108            }
1109    
1110            @Override
1111            public DLFolder updateStatus(
1112                            long userId, long folderId, int status,
1113                            Map<String, Serializable> workflowContext,
1114                            ServiceContext serviceContext)
1115                    throws PortalException {
1116    
1117                    // Folder
1118    
1119                    User user = userPersistence.findByPrimaryKey(userId);
1120    
1121                    DLFolder dlFolder = dlFolderPersistence.findByPrimaryKey(folderId);
1122    
1123                    int oldStatus = dlFolder.getStatus();
1124    
1125                    dlFolder.setStatus(status);
1126                    dlFolder.setStatusByUserId(user.getUserId());
1127                    dlFolder.setStatusByUserName(user.getFullName());
1128                    dlFolder.setStatusDate(new Date());
1129    
1130                    dlFolderPersistence.update(dlFolder);
1131    
1132                    // Asset
1133    
1134                    if (status == WorkflowConstants.STATUS_APPROVED) {
1135                            assetEntryLocalService.updateVisible(
1136                                    DLFolder.class.getName(), dlFolder.getFolderId(), true);
1137                    }
1138                    else if (status == WorkflowConstants.STATUS_IN_TRASH) {
1139                            assetEntryLocalService.updateVisible(
1140                                    DLFolder.class.getName(), dlFolder.getFolderId(), false);
1141                    }
1142    
1143                    // Indexer
1144    
1145                    if (((status == WorkflowConstants.STATUS_APPROVED) ||
1146                             (status == WorkflowConstants.STATUS_IN_TRASH) ||
1147                             (oldStatus == WorkflowConstants.STATUS_IN_TRASH)) &&
1148                            ((serviceContext == null) || serviceContext.isIndexingEnabled())) {
1149    
1150                            Indexer<DLFolder> indexer = IndexerRegistryUtil.nullSafeGetIndexer(
1151                                    DLFolder.class);
1152    
1153                            indexer.reindex(dlFolder);
1154                    }
1155    
1156                    return dlFolder;
1157            }
1158    
1159            @Override
1160            public boolean verifyInheritableLock(long folderId, String lockUuid)
1161                    throws PortalException {
1162    
1163                    boolean verified = false;
1164    
1165                    try {
1166                            Lock lock = LockManagerUtil.getLock(
1167                                    DLFolder.class.getName(), folderId);
1168    
1169                            if (!lock.isInheritable()) {
1170                                    throw new NoSuchLockException("{folderId=" + folderId + "}");
1171                            }
1172    
1173                            if (lock.getUuid().equals(lockUuid)) {
1174                                    verified = true;
1175                            }
1176                    }
1177                    catch (ExpiredLockException ele) {
1178                            throw new NoSuchLockException(ele);
1179                    }
1180    
1181                    return verified;
1182            }
1183    
1184            protected void addFolderResources(
1185                            DLFolder dlFolder, boolean addGroupPermissions,
1186                            boolean addGuestPermissions)
1187                    throws PortalException {
1188    
1189                    resourceLocalService.addResources(
1190                            dlFolder.getCompanyId(), dlFolder.getGroupId(),
1191                            dlFolder.getUserId(), DLFolder.class.getName(),
1192                            dlFolder.getFolderId(), false, addGroupPermissions,
1193                            addGuestPermissions);
1194            }
1195    
1196            protected void addFolderResources(
1197                            DLFolder dlFolder, ModelPermissions modelPermissions)
1198                    throws PortalException {
1199    
1200                    resourceLocalService.addModelResources(
1201                            dlFolder.getCompanyId(), dlFolder.getGroupId(),
1202                            dlFolder.getUserId(), DLFolder.class.getName(),
1203                            dlFolder.getFolderId(), modelPermissions);
1204            }
1205    
1206            protected void addFolderResources(
1207                            long folderId, boolean addGroupPermissions,
1208                            boolean addGuestPermissions)
1209                    throws PortalException {
1210    
1211                    DLFolder dlFolder = dlFolderPersistence.findByPrimaryKey(folderId);
1212    
1213                    addFolderResources(dlFolder, addGroupPermissions, addGuestPermissions);
1214            }
1215    
1216            protected void addFolderResources(
1217                            long folderId, ModelPermissions modelPermissions)
1218                    throws PortalException {
1219    
1220                    DLFolder dlFolder = dlFolderPersistence.findByPrimaryKey(folderId);
1221    
1222                    addFolderResources(dlFolder, modelPermissions);
1223            }
1224    
1225            protected void deleteFolderDependencies(
1226                            DLFolder dlFolder, boolean includeTrashedEntries)
1227                    throws PortalException {
1228    
1229                    // Resources
1230    
1231                    resourceLocalService.deleteResource(
1232                            dlFolder.getCompanyId(), DLFolder.class.getName(),
1233                            ResourceConstants.SCOPE_INDIVIDUAL, dlFolder.getFolderId());
1234    
1235                    // WebDAVProps
1236    
1237                    webDAVPropsLocalService.deleteWebDAVProps(
1238                            DLFolder.class.getName(), dlFolder.getFolderId());
1239    
1240                    // File entries
1241    
1242                    dlFileEntryLocalService.deleteFileEntries(
1243                            dlFolder.getGroupId(), dlFolder.getFolderId(),
1244                            includeTrashedEntries);
1245    
1246                    // File entry types
1247    
1248                    List<Long> fileEntryTypeIds = new ArrayList<>();
1249    
1250                    for (DLFileEntryType dlFileEntryType :
1251                                    dlFileEntryTypeLocalService.getDLFolderDLFileEntryTypes(
1252                                            dlFolder.getFolderId())) {
1253    
1254                            fileEntryTypeIds.add(dlFileEntryType.getFileEntryTypeId());
1255                    }
1256    
1257                    if (fileEntryTypeIds.isEmpty()) {
1258                            fileEntryTypeIds.add(
1259                                    DLFileEntryTypeConstants.FILE_ENTRY_TYPE_ID_ALL);
1260                    }
1261    
1262                    dlFileEntryTypeLocalService.unsetFolderFileEntryTypes(
1263                            dlFolder.getFolderId());
1264    
1265                    // File shortcuts
1266    
1267                    dlFileShortcutLocalService.deleteFileShortcuts(
1268                            dlFolder.getGroupId(), dlFolder.getFolderId(),
1269                            includeTrashedEntries);
1270    
1271                    // Expando
1272    
1273                    expandoRowLocalService.deleteRows(dlFolder.getFolderId());
1274    
1275                    // Ratings
1276    
1277                    ratingsStatsLocalService.deleteStats(
1278                            DLFolder.class.getName(), dlFolder.getFolderId());
1279    
1280                    // Folder
1281    
1282                    dlFolderPersistence.remove(dlFolder);
1283    
1284                    // Directory
1285    
1286                    if (includeTrashedEntries) {
1287                            DLStoreUtil.deleteDirectory(
1288                                    dlFolder.getCompanyId(), dlFolder.getFolderId(),
1289                                    StringPool.BLANK);
1290                    }
1291    
1292                    // Workflow
1293    
1294                    for (long fileEntryTypeId : fileEntryTypeIds) {
1295                            WorkflowDefinitionLink workflowDefinitionLink =
1296                                    workflowDefinitionLinkLocalService.fetchWorkflowDefinitionLink(
1297                                            dlFolder.getCompanyId(), dlFolder.getGroupId(),
1298                                            DLFolder.class.getName(), dlFolder.getFolderId(),
1299                                            fileEntryTypeId);
1300    
1301                            if (workflowDefinitionLink != null) {
1302                                    workflowDefinitionLinkLocalService.deleteWorkflowDefinitionLink(
1303                                            workflowDefinitionLink);
1304                            }
1305                    }
1306            }
1307    
1308            protected void deleteSubfolders(
1309                            DLFolder dlFolder, boolean includeTrashedEntries)
1310                    throws PortalException {
1311    
1312                    RepositoryEventTrigger repositoryEventTrigger =
1313                            RepositoryUtil.getRepositoryEventTrigger(
1314                                    dlFolder.getRepositoryId());
1315    
1316                    List<DLFolder> dlFolders = dlFolderPersistence.findByG_P(
1317                            dlFolder.getGroupId(), dlFolder.getFolderId());
1318    
1319                    for (DLFolder curDLFolder : dlFolders) {
1320                            if (includeTrashedEntries || !curDLFolder.isInTrashExplicitly()) {
1321                                    repositoryEventTrigger.trigger(
1322                                            RepositoryEventType.Delete.class, Folder.class,
1323                                            new LiferayFolder(curDLFolder));
1324    
1325                                    dlFolderLocalService.deleteFolder(
1326                                            curDLFolder, includeTrashedEntries);
1327                            }
1328                    }
1329            }
1330    
1331            protected Set<Long> getFileEntryTypeIds(
1332                    List<DLFileEntryType> dlFileEntryTypes) {
1333    
1334                    Set<Long> fileEntryTypeIds = new HashSet<>();
1335    
1336                    for (DLFileEntryType dlFileEntryType : dlFileEntryTypes) {
1337                            fileEntryTypeIds.add(dlFileEntryType.getFileEntryTypeId());
1338                    }
1339    
1340                    return fileEntryTypeIds;
1341            }
1342    
1343            protected long getParentFolderId(DLFolder dlFolder, long parentFolderId)
1344                    throws PortalException {
1345    
1346                    parentFolderId = getParentFolderId(
1347                            dlFolder.getGroupId(), dlFolder.getRepositoryId(), parentFolderId);
1348    
1349                    if (parentFolderId == DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
1350                            return parentFolderId;
1351                    }
1352    
1353                    if (dlFolder.getFolderId() == parentFolderId) {
1354                            throw new InvalidFolderException(
1355                                    InvalidFolderException.CANNOT_MOVE_INTO_ITSELF, parentFolderId);
1356                    }
1357    
1358                    List<Long> subfolderIds = new ArrayList<>();
1359    
1360                    getGroupSubfolderIds(
1361                            subfolderIds, dlFolder.getGroupId(), dlFolder.getFolderId());
1362    
1363                    if (subfolderIds.contains(parentFolderId)) {
1364                            throw new InvalidFolderException(
1365                                    InvalidFolderException.CANNOT_MOVE_INTO_CHILD_FOLDER,
1366                                    parentFolderId);
1367                    }
1368    
1369                    return parentFolderId;
1370            }
1371    
1372            protected long getParentFolderId(
1373                            long groupId, long repositoryId, long parentFolderId)
1374                    throws PortalException {
1375    
1376                    if (parentFolderId == DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
1377                            return parentFolderId;
1378                    }
1379    
1380                    DLFolder parentDLFolder = dlFolderPersistence.findByPrimaryKey(
1381                            parentFolderId);
1382    
1383                    if (parentDLFolder.getGroupId() != groupId) {
1384                            throw new NoSuchFolderException(
1385                                    String.format(
1386                                            "No folder exists with the primary key %s in group %s",
1387                                            parentFolderId, groupId));
1388                    }
1389    
1390                    if ((parentDLFolder.getRepositoryId() != repositoryId) &&
1391                            (parentDLFolder.getRepositoryId() != groupId)) {
1392    
1393                            Repository repository = repositoryLocalService.getRepository(
1394                                    repositoryId);
1395    
1396                            if (repository.getGroupId() != parentDLFolder.getGroupId()) {
1397                                    throw new NoSuchFolderException(
1398                                            String.format(
1399                                                    "No folder exists with the primary key %s in " +
1400                                                            "repository %s",
1401                                                    parentFolderId, repositoryId));
1402                            }
1403                    }
1404    
1405                    return parentDLFolder.getFolderId();
1406            }
1407    
1408            protected void validateFolder(
1409                            long folderId, long groupId, long parentFolderId, String name)
1410                    throws PortalException {
1411    
1412                    validateFolderName(name);
1413    
1414                    DLValidatorUtil.validateDirectoryName(name);
1415    
1416                    DLFileEntry dlFileEntry = dlFileEntryLocalService.fetchFileEntry(
1417                            groupId, parentFolderId, name);
1418    
1419                    if (dlFileEntry != null) {
1420                            throw new DuplicateFileEntryException(name);
1421                    }
1422    
1423                    DLFolder dlFolder = dlFolderPersistence.fetchByG_P_N(
1424                            groupId, parentFolderId, name);
1425    
1426                    if ((dlFolder != null) && (dlFolder.getFolderId() != folderId)) {
1427                            throw new DuplicateFolderNameException(name);
1428                    }
1429            }
1430    
1431            protected void validateFolder(
1432                            long groupId, long parentFolderId, String name)
1433                    throws PortalException {
1434    
1435                    long folderId = 0;
1436    
1437                    validateFolder(folderId, groupId, parentFolderId, name);
1438            }
1439    
1440            protected void validateFolderName(String folderName)
1441                    throws PortalException {
1442    
1443                    if (folderName.contains(StringPool.SLASH)) {
1444                            throw new FolderNameException(folderName);
1445                    }
1446            }
1447    
1448            private static final Log _log = LogFactoryUtil.getLog(
1449                    DLFolderLocalServiceImpl.class);
1450    
1451    }