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                                    dlFileEntryTypeLocalService.cascadeFileEntryTypes(
863                                            serviceContext.getUserId(), dlFolder);
864                            }
865    
866                            // Workflow definitions
867    
868                            List<ObjectValuePair<Long, String>> workflowDefinitionOVPs =
869                                    new ArrayList<>();
870    
871                            if (restrictionType ==
872                                            DLFolderConstants.
873                                                    RESTRICTION_TYPE_FILE_ENTRY_TYPES_AND_WORKFLOW) {
874    
875                                    workflowDefinitionOVPs.add(
876                                            new ObjectValuePair<Long, String>(
877                                                    DLFileEntryTypeConstants.FILE_ENTRY_TYPE_ID_ALL,
878                                                    StringPool.BLANK));
879    
880                                    for (long fileEntryTypeId : fileEntryTypeIds) {
881                                            String workflowDefinition = ParamUtil.getString(
882                                                    serviceContext, "workflowDefinition" + fileEntryTypeId);
883    
884                                            workflowDefinitionOVPs.add(
885                                                    new ObjectValuePair<Long, String>(
886                                                            fileEntryTypeId, workflowDefinition));
887                                    }
888                            }
889                            else if (restrictionType ==
890                                                    DLFolderConstants.RESTRICTION_TYPE_INHERIT) {
891    
892                                    if (originalFileEntryTypeIds.isEmpty()) {
893                                            originalFileEntryTypeIds.add(
894                                                    DLFileEntryTypeConstants.FILE_ENTRY_TYPE_ID_ALL);
895                                    }
896    
897                                    for (long originalFileEntryTypeId : originalFileEntryTypeIds) {
898                                            workflowDefinitionOVPs.add(
899                                                    new ObjectValuePair<Long, String>(
900                                                            originalFileEntryTypeId, StringPool.BLANK));
901                                    }
902                            }
903                            else if (restrictionType ==
904                                                    DLFolderConstants.RESTRICTION_TYPE_WORKFLOW) {
905    
906                                    String workflowDefinition = ParamUtil.getString(
907                                            serviceContext,
908                                            "workflowDefinition" +
909                                                    DLFileEntryTypeConstants.FILE_ENTRY_TYPE_ID_ALL);
910    
911                                    workflowDefinitionOVPs.add(
912                                            new ObjectValuePair<Long, String>(
913                                                    DLFileEntryTypeConstants.FILE_ENTRY_TYPE_ID_ALL,
914                                                    workflowDefinition));
915    
916                                    for (long originalFileEntryTypeId : originalFileEntryTypeIds) {
917                                            workflowDefinitionOVPs.add(
918                                                    new ObjectValuePair<Long, String>(
919                                                            originalFileEntryTypeId, StringPool.BLANK));
920                                    }
921                            }
922    
923                            workflowDefinitionLinkLocalService.updateWorkflowDefinitionLinks(
924                                    serviceContext.getUserId(), serviceContext.getCompanyId(),
925                                    serviceContext.getScopeGroupId(), DLFolder.class.getName(),
926                                    folderId, workflowDefinitionOVPs);
927    
928                            return dlFolder;
929                    }
930                    finally {
931                            if (!hasLock) {
932    
933                                    // Unlock
934    
935                                    unlockFolder(folderId, lock.getUuid());
936                            }
937                    }
938            }
939    
940            /**
941             * @deprecated As of 7.0.0, replaced {@link #updateFolder(long, long,
942             *             String, String, long, List, int, ServiceContext)}
943             */
944            @Deprecated
945            @Override
946            public DLFolder updateFolder(
947                            long folderId, String name, String description,
948                            long defaultFileEntryTypeId, List<Long> fileEntryTypeIds,
949                            boolean overrideFileEntryTypes, ServiceContext serviceContext)
950                    throws PortalException {
951    
952                    int restrictionType = DLFolderConstants.RESTRICTION_TYPE_INHERIT;
953    
954                    if (overrideFileEntryTypes) {
955                            restrictionType =
956                                    DLFolderConstants.
957                                            RESTRICTION_TYPE_FILE_ENTRY_TYPES_AND_WORKFLOW;
958                    }
959    
960                    return updateFolder(
961                            serviceContext.getScopeGroupId(), folderId, name, description,
962                            defaultFileEntryTypeId, fileEntryTypeIds, restrictionType,
963                            serviceContext);
964            }
965    
966            @Indexable(type = IndexableType.REINDEX)
967            @Override
968            public DLFolder updateFolder(
969                            long folderId, String name, String description,
970                            long defaultFileEntryTypeId, List<Long> fileEntryTypeIds,
971                            int restrictionType, ServiceContext serviceContext)
972                    throws PortalException {
973    
974                    long parentFolderId = DLFolderConstants.DEFAULT_PARENT_FOLDER_ID;
975    
976                    if (folderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
977                            DLFolder dlFolder = getDLFolder(folderId);
978    
979                            parentFolderId = dlFolder.getParentFolderId();
980                    }
981    
982                    return updateFolder(
983                            folderId, parentFolderId, name, description, defaultFileEntryTypeId,
984                            fileEntryTypeIds, restrictionType, serviceContext);
985            }
986    
987            /**
988             * @deprecated As of 7.0.0, replaced by {@link #
989             *             updateFolderAndFileEntryTypes(long, long, long, String,
990             *             String, long, List, int, ServiceContext)}
991             */
992            @Deprecated
993            @Override
994            public DLFolder updateFolderAndFileEntryTypes(
995                            long userId, long folderId, long parentFolderId, String name,
996                            String description, long defaultFileEntryTypeId,
997                            List<Long> fileEntryTypeIds, boolean overrideFileEntryTypes,
998                            ServiceContext serviceContext)
999                    throws PortalException {
1000    
1001                    int restrictionType = DLFolderConstants.RESTRICTION_TYPE_INHERIT;
1002    
1003                    if (overrideFileEntryTypes) {
1004                            restrictionType =
1005                                    DLFolderConstants.
1006                                            RESTRICTION_TYPE_FILE_ENTRY_TYPES_AND_WORKFLOW;
1007                    }
1008    
1009                    return updateFolderAndFileEntryTypes(
1010                            userId, folderId, parentFolderId, name, description,
1011                            defaultFileEntryTypeId, fileEntryTypeIds, restrictionType,
1012                            serviceContext);
1013            }
1014    
1015            @Override
1016            public DLFolder updateFolderAndFileEntryTypes(
1017                            long userId, long folderId, long parentFolderId, String name,
1018                            String description, long defaultFileEntryTypeId,
1019                            List<Long> fileEntryTypeIds, int restrictionType,
1020                            ServiceContext serviceContext)
1021                    throws PortalException {
1022    
1023                    if ((restrictionType ==
1024                                    DLFolderConstants.
1025                                            RESTRICTION_TYPE_FILE_ENTRY_TYPES_AND_WORKFLOW) &&
1026                            fileEntryTypeIds.isEmpty()) {
1027    
1028                            throw new RequiredFileEntryTypeException(
1029                                    "File entry type IDs is empty");
1030                    }
1031    
1032                    boolean hasLock = hasFolderLock(userId, folderId);
1033    
1034                    Lock lock = null;
1035    
1036                    if (!hasLock) {
1037    
1038                            // Lock
1039    
1040                            lock = lockFolder(
1041                                    userId, folderId, null, false,
1042                                    DLFolderImpl.LOCK_EXPIRATION_TIME);
1043                    }
1044    
1045                    try {
1046    
1047                            // Folder
1048    
1049                            if (restrictionType == DLFolderConstants.RESTRICTION_TYPE_INHERIT) {
1050                                    fileEntryTypeIds = Collections.emptyList();
1051                            }
1052    
1053                            DLFolder dlFolder = dlFolderPersistence.findByPrimaryKey(folderId);
1054    
1055                            parentFolderId = getParentFolderId(dlFolder, parentFolderId);
1056    
1057                            validateFolder(
1058                                    folderId, dlFolder.getGroupId(), parentFolderId, name);
1059    
1060                            long oldParentFolderId = dlFolder.getParentFolderId();
1061    
1062                            if (oldParentFolderId != parentFolderId) {
1063                                    dlFolder.setParentFolderId(parentFolderId);
1064                                    dlFolder.setTreePath(dlFolder.buildTreePath());
1065                            }
1066    
1067                            dlFolder.setName(name);
1068                            dlFolder.setDescription(description);
1069                            dlFolder.setExpandoBridgeAttributes(serviceContext);
1070                            dlFolder.setRestrictionType(restrictionType);
1071                            dlFolder.setDefaultFileEntryTypeId(defaultFileEntryTypeId);
1072    
1073                            dlFolderPersistence.update(dlFolder);
1074    
1075                            // File entry types
1076    
1077                            if (fileEntryTypeIds != null) {
1078                                    dlFileEntryTypeLocalService.updateFolderFileEntryTypes(
1079                                            dlFolder, fileEntryTypeIds, defaultFileEntryTypeId,
1080                                            serviceContext);
1081                            }
1082    
1083                            if (oldParentFolderId != parentFolderId) {
1084                                    rebuildTree(
1085                                            dlFolder.getCompanyId(), folderId, dlFolder.getTreePath(),
1086                                            true);
1087                            }
1088    
1089                            return dlFolder;
1090                    }
1091                    finally {
1092                            if (!hasLock) {
1093    
1094                                    // Unlock
1095    
1096                                    unlockFolder(folderId, lock.getUuid());
1097                            }
1098                    }
1099            }
1100    
1101            @BufferedIncrement(
1102                    configuration = "DLFolderEntry",
1103                    incrementClass = DateOverrideIncrement.class
1104            )
1105            @Override
1106            public void updateLastPostDate(long folderId, Date lastPostDate)
1107                    throws PortalException {
1108    
1109                    if (ExportImportThreadLocal.isImportInProcess() ||
1110                            (folderId == DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) ||
1111                            (lastPostDate == null)) {
1112    
1113                            return;
1114                    }
1115    
1116                    DLFolder dlFolder = dlFolderPersistence.findByPrimaryKey(folderId);
1117    
1118                    if (lastPostDate.before(dlFolder.getLastPostDate())) {
1119                            return;
1120                    }
1121    
1122                    dlFolder.setModifiedDate(dlFolder.getModifiedDate());
1123                    dlFolder.setLastPostDate(lastPostDate);
1124    
1125                    dlFolderPersistence.update(dlFolder);
1126            }
1127    
1128            @Override
1129            public DLFolder updateStatus(
1130                            long userId, long folderId, int status,
1131                            Map<String, Serializable> workflowContext,
1132                            ServiceContext serviceContext)
1133                    throws PortalException {
1134    
1135                    // Folder
1136    
1137                    User user = userPersistence.findByPrimaryKey(userId);
1138    
1139                    DLFolder dlFolder = dlFolderPersistence.findByPrimaryKey(folderId);
1140    
1141                    int oldStatus = dlFolder.getStatus();
1142    
1143                    dlFolder.setStatus(status);
1144                    dlFolder.setStatusByUserId(user.getUserId());
1145                    dlFolder.setStatusByUserName(user.getFullName());
1146                    dlFolder.setStatusDate(new Date());
1147    
1148                    dlFolderPersistence.update(dlFolder);
1149    
1150                    // Asset
1151    
1152                    if (status == WorkflowConstants.STATUS_APPROVED) {
1153                            assetEntryLocalService.updateVisible(
1154                                    DLFolder.class.getName(), dlFolder.getFolderId(), true);
1155                    }
1156                    else if (status == WorkflowConstants.STATUS_IN_TRASH) {
1157                            assetEntryLocalService.updateVisible(
1158                                    DLFolder.class.getName(), dlFolder.getFolderId(), false);
1159                    }
1160    
1161                    // Indexer
1162    
1163                    if (((status == WorkflowConstants.STATUS_APPROVED) ||
1164                             (status == WorkflowConstants.STATUS_IN_TRASH) ||
1165                             (oldStatus == WorkflowConstants.STATUS_IN_TRASH)) &&
1166                            ((serviceContext == null) || serviceContext.isIndexingEnabled())) {
1167    
1168                            Indexer<DLFolder> indexer = IndexerRegistryUtil.nullSafeGetIndexer(
1169                                    DLFolder.class);
1170    
1171                            indexer.reindex(dlFolder);
1172                    }
1173    
1174                    return dlFolder;
1175            }
1176    
1177            @Override
1178            public boolean verifyInheritableLock(long folderId, String lockUuid)
1179                    throws PortalException {
1180    
1181                    boolean verified = false;
1182    
1183                    try {
1184                            Lock lock = LockManagerUtil.getLock(
1185                                    DLFolder.class.getName(), folderId);
1186    
1187                            if (!lock.isInheritable()) {
1188                                    throw new NoSuchLockException("{folderId=" + folderId + "}");
1189                            }
1190    
1191                            if (lock.getUuid().equals(lockUuid)) {
1192                                    verified = true;
1193                            }
1194                    }
1195                    catch (ExpiredLockException ele) {
1196                            throw new NoSuchLockException(ele);
1197                    }
1198    
1199                    return verified;
1200            }
1201    
1202            protected void addFolderResources(
1203                            DLFolder dlFolder, boolean addGroupPermissions,
1204                            boolean addGuestPermissions)
1205                    throws PortalException {
1206    
1207                    resourceLocalService.addResources(
1208                            dlFolder.getCompanyId(), dlFolder.getGroupId(),
1209                            dlFolder.getUserId(), DLFolder.class.getName(),
1210                            dlFolder.getFolderId(), false, addGroupPermissions,
1211                            addGuestPermissions);
1212            }
1213    
1214            protected void addFolderResources(
1215                            DLFolder dlFolder, ModelPermissions modelPermissions)
1216                    throws PortalException {
1217    
1218                    resourceLocalService.addModelResources(
1219                            dlFolder.getCompanyId(), dlFolder.getGroupId(),
1220                            dlFolder.getUserId(), DLFolder.class.getName(),
1221                            dlFolder.getFolderId(), modelPermissions);
1222            }
1223    
1224            protected void addFolderResources(
1225                            long folderId, boolean addGroupPermissions,
1226                            boolean addGuestPermissions)
1227                    throws PortalException {
1228    
1229                    DLFolder dlFolder = dlFolderPersistence.findByPrimaryKey(folderId);
1230    
1231                    addFolderResources(dlFolder, addGroupPermissions, addGuestPermissions);
1232            }
1233    
1234            protected void addFolderResources(
1235                            long folderId, ModelPermissions modelPermissions)
1236                    throws PortalException {
1237    
1238                    DLFolder dlFolder = dlFolderPersistence.findByPrimaryKey(folderId);
1239    
1240                    addFolderResources(dlFolder, modelPermissions);
1241            }
1242    
1243            protected void deleteFolderDependencies(
1244                            DLFolder dlFolder, boolean includeTrashedEntries)
1245                    throws PortalException {
1246    
1247                    // Resources
1248    
1249                    resourceLocalService.deleteResource(
1250                            dlFolder.getCompanyId(), DLFolder.class.getName(),
1251                            ResourceConstants.SCOPE_INDIVIDUAL, dlFolder.getFolderId());
1252    
1253                    // WebDAVProps
1254    
1255                    webDAVPropsLocalService.deleteWebDAVProps(
1256                            DLFolder.class.getName(), dlFolder.getFolderId());
1257    
1258                    // File entries
1259    
1260                    dlFileEntryLocalService.deleteFileEntries(
1261                            dlFolder.getGroupId(), dlFolder.getFolderId(),
1262                            includeTrashedEntries);
1263    
1264                    // File entry types
1265    
1266                    List<Long> fileEntryTypeIds = new ArrayList<>();
1267    
1268                    for (DLFileEntryType dlFileEntryType :
1269                                    dlFileEntryTypeLocalService.getDLFolderDLFileEntryTypes(
1270                                            dlFolder.getFolderId())) {
1271    
1272                            fileEntryTypeIds.add(dlFileEntryType.getFileEntryTypeId());
1273                    }
1274    
1275                    if (fileEntryTypeIds.isEmpty()) {
1276                            fileEntryTypeIds.add(
1277                                    DLFileEntryTypeConstants.FILE_ENTRY_TYPE_ID_ALL);
1278                    }
1279    
1280                    dlFileEntryTypeLocalService.unsetFolderFileEntryTypes(
1281                            dlFolder.getFolderId());
1282    
1283                    // File shortcuts
1284    
1285                    dlFileShortcutLocalService.deleteFileShortcuts(
1286                            dlFolder.getGroupId(), dlFolder.getFolderId(),
1287                            includeTrashedEntries);
1288    
1289                    // Expando
1290    
1291                    expandoRowLocalService.deleteRows(dlFolder.getFolderId());
1292    
1293                    // Ratings
1294    
1295                    ratingsStatsLocalService.deleteStats(
1296                            DLFolder.class.getName(), dlFolder.getFolderId());
1297    
1298                    // Folder
1299    
1300                    dlFolderPersistence.remove(dlFolder);
1301    
1302                    // Directory
1303    
1304                    if (includeTrashedEntries) {
1305                            DLStoreUtil.deleteDirectory(
1306                                    dlFolder.getCompanyId(), dlFolder.getFolderId(),
1307                                    StringPool.BLANK);
1308                    }
1309    
1310                    // Workflow
1311    
1312                    for (long fileEntryTypeId : fileEntryTypeIds) {
1313                            WorkflowDefinitionLink workflowDefinitionLink =
1314                                    workflowDefinitionLinkLocalService.fetchWorkflowDefinitionLink(
1315                                            dlFolder.getCompanyId(), dlFolder.getGroupId(),
1316                                            DLFolder.class.getName(), dlFolder.getFolderId(),
1317                                            fileEntryTypeId);
1318    
1319                            if (workflowDefinitionLink != null) {
1320                                    workflowDefinitionLinkLocalService.deleteWorkflowDefinitionLink(
1321                                            workflowDefinitionLink);
1322                            }
1323                    }
1324            }
1325    
1326            protected void deleteSubfolders(
1327                            DLFolder dlFolder, boolean includeTrashedEntries)
1328                    throws PortalException {
1329    
1330                    RepositoryEventTrigger repositoryEventTrigger =
1331                            RepositoryUtil.getRepositoryEventTrigger(
1332                                    dlFolder.getRepositoryId());
1333    
1334                    List<DLFolder> dlFolders = dlFolderPersistence.findByG_P(
1335                            dlFolder.getGroupId(), dlFolder.getFolderId());
1336    
1337                    for (DLFolder curDLFolder : dlFolders) {
1338                            if (includeTrashedEntries || !curDLFolder.isInTrashExplicitly()) {
1339                                    repositoryEventTrigger.trigger(
1340                                            RepositoryEventType.Delete.class, Folder.class,
1341                                            new LiferayFolder(curDLFolder));
1342    
1343                                    dlFolderLocalService.deleteFolder(
1344                                            curDLFolder, includeTrashedEntries);
1345                            }
1346                    }
1347            }
1348    
1349            protected Set<Long> getFileEntryTypeIds(
1350                    List<DLFileEntryType> dlFileEntryTypes) {
1351    
1352                    Set<Long> fileEntryTypeIds = new HashSet<>();
1353    
1354                    for (DLFileEntryType dlFileEntryType : dlFileEntryTypes) {
1355                            fileEntryTypeIds.add(dlFileEntryType.getFileEntryTypeId());
1356                    }
1357    
1358                    return fileEntryTypeIds;
1359            }
1360    
1361            protected long getParentFolderId(DLFolder dlFolder, long parentFolderId)
1362                    throws PortalException {
1363    
1364                    parentFolderId = getParentFolderId(
1365                            dlFolder.getGroupId(), dlFolder.getRepositoryId(), parentFolderId);
1366    
1367                    if (parentFolderId == DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
1368                            return parentFolderId;
1369                    }
1370    
1371                    if (dlFolder.getFolderId() == parentFolderId) {
1372                            throw new InvalidFolderException(
1373                                    InvalidFolderException.CANNOT_MOVE_INTO_ITSELF, parentFolderId);
1374                    }
1375    
1376                    List<Long> subfolderIds = new ArrayList<>();
1377    
1378                    getGroupSubfolderIds(
1379                            subfolderIds, dlFolder.getGroupId(), dlFolder.getFolderId());
1380    
1381                    if (subfolderIds.contains(parentFolderId)) {
1382                            throw new InvalidFolderException(
1383                                    InvalidFolderException.CANNOT_MOVE_INTO_CHILD_FOLDER,
1384                                    parentFolderId);
1385                    }
1386    
1387                    return parentFolderId;
1388            }
1389    
1390            protected long getParentFolderId(
1391                            long groupId, long repositoryId, long parentFolderId)
1392                    throws PortalException {
1393    
1394                    if (parentFolderId == DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
1395                            return parentFolderId;
1396                    }
1397    
1398                    DLFolder parentDLFolder = dlFolderPersistence.findByPrimaryKey(
1399                            parentFolderId);
1400    
1401                    if (parentDLFolder.getGroupId() != groupId) {
1402                            throw new NoSuchFolderException(
1403                                    String.format(
1404                                            "No folder exists with the primary key %s in group %s",
1405                                            parentFolderId, groupId));
1406                    }
1407    
1408                    if ((parentDLFolder.getRepositoryId() != repositoryId) &&
1409                            (parentDLFolder.getRepositoryId() != groupId)) {
1410    
1411                            Repository repository = repositoryLocalService.getRepository(
1412                                    repositoryId);
1413    
1414                            if (repository.getGroupId() != parentDLFolder.getGroupId()) {
1415                                    throw new NoSuchFolderException(
1416                                            String.format(
1417                                                    "No folder exists with the primary key %s in " +
1418                                                            "repository %s",
1419                                                    parentFolderId, repositoryId));
1420                            }
1421                    }
1422    
1423                    return parentDLFolder.getFolderId();
1424            }
1425    
1426            protected void validateFolder(
1427                            long folderId, long groupId, long parentFolderId, String name)
1428                    throws PortalException {
1429    
1430                    validateFolderName(name);
1431    
1432                    DLValidatorUtil.validateDirectoryName(name);
1433    
1434                    DLFileEntry dlFileEntry = dlFileEntryLocalService.fetchFileEntry(
1435                            groupId, parentFolderId, name);
1436    
1437                    if (dlFileEntry != null) {
1438                            throw new DuplicateFileEntryException(name);
1439                    }
1440    
1441                    DLFolder dlFolder = dlFolderPersistence.fetchByG_P_N(
1442                            groupId, parentFolderId, name);
1443    
1444                    if ((dlFolder != null) && (dlFolder.getFolderId() != folderId)) {
1445                            throw new DuplicateFolderNameException(name);
1446                    }
1447            }
1448    
1449            protected void validateFolder(
1450                            long groupId, long parentFolderId, String name)
1451                    throws PortalException {
1452    
1453                    long folderId = 0;
1454    
1455                    validateFolder(folderId, groupId, parentFolderId, name);
1456            }
1457    
1458            protected void validateFolderName(String folderName)
1459                    throws PortalException {
1460    
1461                    if (folderName.contains(StringPool.SLASH)) {
1462                            throw new FolderNameException(folderName);
1463                    }
1464            }
1465    
1466            private static final Log _log = LogFactoryUtil.getLog(
1467                    DLFolderLocalServiceImpl.class);
1468    
1469    }