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