001    /**
002     * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.bookmarks.service.impl;
016    
017    import com.liferay.portal.kernel.dao.orm.QueryDefinition;
018    import com.liferay.portal.kernel.exception.PortalException;
019    import com.liferay.portal.kernel.exception.SystemException;
020    import com.liferay.portal.kernel.json.JSONFactoryUtil;
021    import com.liferay.portal.kernel.json.JSONObject;
022    import com.liferay.portal.kernel.search.Indexable;
023    import com.liferay.portal.kernel.search.IndexableType;
024    import com.liferay.portal.kernel.search.Indexer;
025    import com.liferay.portal.kernel.search.IndexerRegistryUtil;
026    import com.liferay.portal.kernel.systemevent.SystemEvent;
027    import com.liferay.portal.kernel.util.ContentTypes;
028    import com.liferay.portal.kernel.util.Validator;
029    import com.liferay.portal.kernel.workflow.WorkflowConstants;
030    import com.liferay.portal.model.ResourceConstants;
031    import com.liferay.portal.model.SystemEventConstants;
032    import com.liferay.portal.model.User;
033    import com.liferay.portal.service.ServiceContext;
034    import com.liferay.portlet.asset.model.AssetEntry;
035    import com.liferay.portlet.asset.model.AssetLinkConstants;
036    import com.liferay.portlet.bookmarks.FolderNameException;
037    import com.liferay.portlet.bookmarks.model.BookmarksEntry;
038    import com.liferay.portlet.bookmarks.model.BookmarksFolder;
039    import com.liferay.portlet.bookmarks.model.BookmarksFolderConstants;
040    import com.liferay.portlet.bookmarks.service.base.BookmarksFolderLocalServiceBaseImpl;
041    import com.liferay.portlet.social.model.SocialActivityConstants;
042    import com.liferay.portlet.trash.model.TrashEntry;
043    
044    import java.util.ArrayList;
045    import java.util.Date;
046    import java.util.List;
047    
048    /**
049     * @author Brian Wing Shun Chan
050     * @author Wesley Gong
051     */
052    public class BookmarksFolderLocalServiceImpl
053            extends BookmarksFolderLocalServiceBaseImpl {
054    
055            @Override
056            public BookmarksFolder addFolder(
057                            long userId, long parentFolderId, String name, String description,
058                            ServiceContext serviceContext)
059                    throws PortalException, SystemException {
060    
061                    // Folder
062    
063                    User user = userPersistence.findByPrimaryKey(userId);
064                    long groupId = serviceContext.getScopeGroupId();
065                    parentFolderId = getParentFolderId(groupId, parentFolderId);
066                    Date now = new Date();
067    
068                    validate(name);
069    
070                    long folderId = counterLocalService.increment();
071    
072                    BookmarksFolder folder = bookmarksFolderPersistence.create(folderId);
073    
074                    folder.setUuid(serviceContext.getUuid());
075                    folder.setGroupId(groupId);
076                    folder.setCompanyId(user.getCompanyId());
077                    folder.setUserId(user.getUserId());
078                    folder.setUserName(user.getFullName());
079                    folder.setCreateDate(serviceContext.getCreateDate(now));
080                    folder.setModifiedDate(serviceContext.getModifiedDate(now));
081                    folder.setParentFolderId(parentFolderId);
082                    folder.setTreePath(folder.buildTreePath());
083                    folder.setName(name);
084                    folder.setDescription(description);
085                    folder.setExpandoBridgeAttributes(serviceContext);
086    
087                    bookmarksFolderPersistence.update(folder);
088    
089                    // Resources
090    
091                    resourceLocalService.addModelResources(folder, serviceContext);
092    
093                    // Asset
094    
095                    updateAsset(
096                            userId, folder, serviceContext.getAssetCategoryIds(),
097                            serviceContext.getAssetTagNames(),
098                            serviceContext.getAssetLinkEntryIds());
099    
100                    return folder;
101            }
102    
103            @Indexable(type = IndexableType.DELETE)
104            @Override
105            @SystemEvent(
106                    action = SystemEventConstants.ACTION_SKIP, send = false,
107                    type = SystemEventConstants.TYPE_DELETE)
108            public BookmarksFolder deleteFolder(BookmarksFolder folder)
109                    throws PortalException, SystemException {
110    
111                    return deleteFolder(folder, true);
112            }
113    
114            @Indexable(type = IndexableType.DELETE)
115            @Override
116            @SystemEvent(
117                    action = SystemEventConstants.ACTION_SKIP, send = false,
118                    type = SystemEventConstants.TYPE_DELETE)
119            public BookmarksFolder deleteFolder(
120                            BookmarksFolder folder, boolean includeTrashedEntries)
121                    throws PortalException, SystemException {
122    
123                    List<BookmarksFolder> folders = bookmarksFolderPersistence.findByG_P(
124                            folder.getGroupId(), folder.getFolderId());
125    
126                    for (BookmarksFolder curFolder : folders) {
127                            if (includeTrashedEntries || !curFolder.isInTrash()) {
128                                    deleteFolder(curFolder);
129                            }
130                    }
131    
132                    // Folder
133    
134                    bookmarksFolderPersistence.remove(folder);
135    
136                    // Resources
137    
138                    resourceLocalService.deleteResource(
139                            folder, ResourceConstants.SCOPE_INDIVIDUAL);
140    
141                    // Entries
142    
143                    bookmarksEntryLocalService.deleteEntries(
144                            folder.getGroupId(), folder.getFolderId(), includeTrashedEntries);
145    
146                    // Asset
147    
148                    assetEntryLocalService.deleteEntry(
149                            BookmarksFolder.class.getName(), folder.getFolderId());
150    
151                    // Expando
152    
153                    expandoRowLocalService.deleteRows(folder.getFolderId());
154    
155                    // Subscriptions
156    
157                    subscriptionLocalService.deleteSubscriptions(
158                            folder.getCompanyId(), BookmarksFolder.class.getName(),
159                            folder.getFolderId());
160    
161                    // Trash
162    
163                    trashEntryLocalService.deleteEntry(
164                            BookmarksFolder.class.getName(), folder.getFolderId());
165    
166                    return folder;
167            }
168    
169            @Indexable(type = IndexableType.DELETE)
170            @Override
171            public BookmarksFolder deleteFolder(long folderId)
172                    throws PortalException, SystemException {
173    
174                    BookmarksFolder folder = bookmarksFolderPersistence.findByPrimaryKey(
175                            folderId);
176    
177                    return bookmarksFolderLocalService.deleteFolder(folder);
178            }
179    
180            @Indexable(type = IndexableType.DELETE)
181            @Override
182            public BookmarksFolder deleteFolder(
183                            long folderId, boolean includeTrashedEntries)
184                    throws PortalException, SystemException {
185    
186                    BookmarksFolder folder = bookmarksFolderLocalService.getFolder(
187                            folderId);
188    
189                    return bookmarksFolderLocalService.deleteFolder(
190                            folder, includeTrashedEntries);
191            }
192    
193            @Override
194            public void deleteFolders(long groupId)
195                    throws PortalException, SystemException {
196    
197                    List<BookmarksFolder> folders =
198                            bookmarksFolderPersistence.findByGroupId(groupId);
199    
200                    for (BookmarksFolder folder : folders) {
201                            bookmarksFolderLocalService.deleteFolder(folder);
202                    }
203            }
204    
205            @Override
206            public List<BookmarksFolder> getCompanyFolders(
207                            long companyId, int start, int end)
208                    throws SystemException {
209    
210                    return bookmarksFolderPersistence.findByCompanyId(
211                            companyId, start, end);
212            }
213    
214            @Override
215            public int getCompanyFoldersCount(long companyId) throws SystemException {
216                    return bookmarksFolderPersistence.countByCompanyId(companyId);
217            }
218    
219            @Override
220            public BookmarksFolder getFolder(long folderId)
221                    throws PortalException, SystemException {
222    
223                    return bookmarksFolderPersistence.findByPrimaryKey(folderId);
224            }
225    
226            @Override
227            public List<BookmarksFolder> getFolders(long groupId)
228                    throws SystemException {
229    
230                    return bookmarksFolderPersistence.findByGroupId(groupId);
231            }
232    
233            @Override
234            public List<BookmarksFolder> getFolders(long groupId, long parentFolderId)
235                    throws SystemException {
236    
237                    return bookmarksFolderPersistence.findByG_P(groupId, parentFolderId);
238            }
239    
240            @Override
241            public List<BookmarksFolder> getFolders(
242                            long groupId, long parentFolderId, int start, int end)
243                    throws SystemException {
244    
245                    return getFolders(
246                            groupId, parentFolderId, WorkflowConstants.STATUS_APPROVED, start,
247                            end);
248            }
249    
250            @Override
251            public List<BookmarksFolder> getFolders(
252                            long groupId, long parentFolderId, int status, int start, int end)
253                    throws SystemException {
254    
255                    return bookmarksFolderPersistence.findByG_P_S(
256                            groupId, parentFolderId, status, start, end);
257            }
258    
259            @Override
260            public List<Object> getFoldersAndEntries(long groupId, long folderId)
261                    throws SystemException {
262    
263                    return getFoldersAndEntries(
264                            groupId, folderId, WorkflowConstants.STATUS_ANY);
265            }
266    
267            @Override
268            public List<Object> getFoldersAndEntries(
269                            long groupId, long folderId, int status)
270                    throws SystemException {
271    
272                    QueryDefinition queryDefinition = new QueryDefinition(status);
273    
274                    return bookmarksFolderFinder.findF_E_ByG_F(
275                            groupId, folderId, queryDefinition);
276            }
277    
278            @Override
279            public List<Object> getFoldersAndEntries(
280                            long groupId, long folderId, int status, int start, int end)
281                    throws SystemException {
282    
283                    QueryDefinition queryDefinition = new QueryDefinition(
284                            status, start, end, null);
285    
286                    return bookmarksFolderFinder.findF_E_ByG_F(
287                            groupId, folderId, queryDefinition);
288            }
289    
290            @Override
291            public int getFoldersAndEntriesCount(
292                            long groupId, long folderId, int status)
293                    throws SystemException {
294    
295                    QueryDefinition queryDefinition = new QueryDefinition(status);
296    
297                    return bookmarksFolderFinder.countF_E_ByG_F(
298                            groupId, folderId, queryDefinition);
299            }
300    
301            @Override
302            public int getFoldersCount(long groupId, long parentFolderId)
303                    throws SystemException {
304    
305                    return getFoldersCount(
306                            groupId, parentFolderId, WorkflowConstants.STATUS_APPROVED);
307            }
308    
309            @Override
310            public int getFoldersCount(long groupId, long parentFolderId, int status)
311                    throws SystemException {
312    
313                    return bookmarksFolderPersistence.countByG_P_S(
314                            groupId, parentFolderId, status);
315            }
316    
317            @Override
318            public List<BookmarksFolder> getNoAssetFolders() throws SystemException {
319                    return bookmarksFolderFinder.findByNoAssets();
320            }
321    
322            @Override
323            public void getSubfolderIds(
324                            List<Long> folderIds, long groupId, long folderId)
325                    throws SystemException {
326    
327                    List<BookmarksFolder> folders = bookmarksFolderPersistence.findByG_P(
328                            groupId, folderId);
329    
330                    for (BookmarksFolder folder : folders) {
331                            folderIds.add(folder.getFolderId());
332    
333                            getSubfolderIds(
334                                    folderIds, folder.getGroupId(), folder.getFolderId());
335                    }
336            }
337    
338            @Indexable(type = IndexableType.REINDEX)
339            @Override
340            public BookmarksFolder moveFolder(long folderId, long parentFolderId)
341                    throws PortalException, SystemException {
342    
343                    BookmarksFolder folder = bookmarksFolderPersistence.findByPrimaryKey(
344                            folderId);
345    
346                    folder.setParentFolderId(parentFolderId);
347                    folder.setTreePath(folder.buildTreePath());
348    
349                    bookmarksFolderPersistence.update(folder);
350    
351                    return folder;
352            }
353    
354            @Override
355            public BookmarksFolder moveFolderFromTrash(
356                            long userId, long folderId, long parentFolderId)
357                    throws PortalException, SystemException {
358    
359                    BookmarksFolder folder = bookmarksFolderPersistence.findByPrimaryKey(
360                            folderId);
361    
362                    if (folder.isInTrash()) {
363                            restoreFolderFromTrash(userId, folderId);
364                    }
365                    else {
366                            updateStatus(userId, folder, WorkflowConstants.STATUS_APPROVED);
367                    }
368    
369                    return bookmarksFolderLocalService.moveFolder(folderId, parentFolderId);
370            }
371    
372            @Indexable(type = IndexableType.REINDEX)
373            @Override
374            public BookmarksFolder moveFolderToTrash(long userId, long folderId)
375                    throws PortalException, SystemException {
376    
377                    // Folder
378    
379                    BookmarksFolder folder = bookmarksFolderPersistence.findByPrimaryKey(
380                            folderId);
381    
382                    updateStatus(userId, folder, WorkflowConstants.STATUS_IN_TRASH);
383    
384                    // Social
385    
386                    JSONObject extraDataJSONObject = JSONFactoryUtil.createJSONObject();
387    
388                    extraDataJSONObject.put("title", folder.getName());
389    
390                    socialActivityLocalService.addActivity(
391                            userId, folder.getGroupId(), BookmarksFolder.class.getName(),
392                            folder.getFolderId(), SocialActivityConstants.TYPE_MOVE_TO_TRASH,
393                            extraDataJSONObject.toString(), 0);
394    
395                    return folder;
396            }
397    
398            @Override
399            public void rebuildTree(long companyId)
400                    throws PortalException, SystemException {
401    
402                    List<BookmarksFolder> folders = bookmarksFolderPersistence.findByC_NotS(
403                            companyId, WorkflowConstants.STATUS_IN_TRASH);
404    
405                    for (BookmarksFolder folder : folders) {
406                            if (folder.isInTrashContainer()) {
407                                    continue;
408                            }
409    
410                            folder.setTreePath(folder.buildTreePath());
411    
412                            bookmarksFolderPersistence.update(folder);
413                    }
414            }
415    
416            @Indexable(type = IndexableType.REINDEX)
417            @Override
418            public void restoreFolderFromTrash(long userId, long folderId)
419                    throws PortalException, SystemException {
420    
421                    // Folder
422    
423                    BookmarksFolder folder = bookmarksFolderPersistence.findByPrimaryKey(
424                            folderId);
425    
426                    TrashEntry trashEntry = trashEntryLocalService.getEntry(
427                            BookmarksFolder.class.getName(), folderId);
428    
429                    updateStatus(userId, folder, trashEntry.getStatus());
430    
431                    // Social
432    
433                    JSONObject extraDataJSONObject = JSONFactoryUtil.createJSONObject();
434    
435                    extraDataJSONObject.put("title", folder.getName());
436    
437                    socialActivityLocalService.addActivity(
438                            userId, folder.getGroupId(), BookmarksFolder.class.getName(),
439                            folder.getFolderId(),
440                            SocialActivityConstants.TYPE_RESTORE_FROM_TRASH,
441                            extraDataJSONObject.toString(), 0);
442            }
443    
444            @Override
445            public void subscribeFolder(long userId, long groupId, long folderId)
446                    throws PortalException, SystemException {
447    
448                    if (folderId == BookmarksFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
449                            folderId = groupId;
450                    }
451    
452                    subscriptionLocalService.addSubscription(
453                            userId, groupId, BookmarksFolder.class.getName(), folderId);
454            }
455    
456            @Override
457            public void unsubscribeFolder(long userId, long groupId, long folderId)
458                    throws PortalException, SystemException {
459    
460                    if (folderId == BookmarksFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
461                            folderId = groupId;
462                    }
463    
464                    subscriptionLocalService.deleteSubscription(
465                            userId, BookmarksFolder.class.getName(), folderId);
466            }
467    
468            @Override
469            public void updateAsset(
470                            long userId, BookmarksFolder folder, long[] assetCategoryIds,
471                            String[] assetTagNames, long[] assetLinkEntryIds)
472                    throws PortalException, SystemException {
473    
474                    AssetEntry assetEntry = assetEntryLocalService.updateEntry(
475                            userId, folder.getGroupId(), folder.getCreateDate(),
476                            folder.getModifiedDate(), BookmarksFolder.class.getName(),
477                            folder.getFolderId(), folder.getUuid(), 0, assetCategoryIds,
478                            assetTagNames, true, null, null, null, ContentTypes.TEXT_PLAIN,
479                            folder.getName(), folder.getDescription(), null, null, null, 0, 0,
480                            null, false);
481    
482                    assetLinkLocalService.updateLinks(
483                            userId, assetEntry.getEntryId(), assetLinkEntryIds,
484                            AssetLinkConstants.TYPE_RELATED);
485            }
486    
487            @Indexable(type = IndexableType.REINDEX)
488            @Override
489            public BookmarksFolder updateFolder(
490                            long userId, long folderId, long parentFolderId, String name,
491                            String description, boolean mergeWithParentFolder,
492                            ServiceContext serviceContext)
493                    throws PortalException, SystemException {
494    
495                    // Merge folders
496    
497                    BookmarksFolder folder = bookmarksFolderPersistence.findByPrimaryKey(
498                            folderId);
499    
500                    parentFolderId = getParentFolderId(folder, parentFolderId);
501    
502                    if (mergeWithParentFolder && (folderId != parentFolderId)) {
503                            mergeFolders(folder, parentFolderId);
504    
505                            return folder;
506                    }
507    
508                    // Folder
509    
510                    validate(name);
511    
512                    folder.setModifiedDate(serviceContext.getModifiedDate(null));
513                    folder.setParentFolderId(parentFolderId);
514                    folder.setTreePath(folder.buildTreePath());
515                    folder.setName(name);
516                    folder.setDescription(description);
517                    folder.setExpandoBridgeAttributes(serviceContext);
518    
519                    bookmarksFolderPersistence.update(folder);
520    
521                    // Asset
522    
523                    updateAsset(
524                            userId, folder, serviceContext.getAssetCategoryIds(),
525                            serviceContext.getAssetTagNames(),
526                            serviceContext.getAssetLinkEntryIds());
527    
528                    return folder;
529            }
530    
531            @Override
532            public BookmarksFolder updateStatus(
533                            long userId, BookmarksFolder folder, int status)
534                    throws PortalException, SystemException {
535    
536                    // Folder
537    
538                    User user = userPersistence.findByPrimaryKey(userId);
539    
540                    int oldStatus = folder.getStatus();
541    
542                    folder.setStatus(status);
543                    folder.setStatusByUserId(userId);
544                    folder.setStatusByUserName(user.getFullName());
545                    folder.setStatusDate(new Date());
546    
547                    bookmarksFolderPersistence.update(folder);
548    
549                    // Folders and entries
550    
551                    List<Object> foldersAndEntries =
552                            bookmarksFolderLocalService.getFoldersAndEntries(
553                                    folder.getGroupId(), folder.getFolderId());
554    
555                    updateDependentStatus(foldersAndEntries, status);
556    
557                    if (status == WorkflowConstants.STATUS_APPROVED) {
558    
559                            // Asset
560    
561                            assetEntryLocalService.updateVisible(
562                                    BookmarksFolder.class.getName(), folder.getFolderId(), true);
563                    }
564                    else if (status == WorkflowConstants.STATUS_IN_TRASH) {
565    
566                            // Asset
567    
568                            assetEntryLocalService.updateVisible(
569                                    BookmarksFolder.class.getName(), folder.getFolderId(), false);
570                    }
571    
572                    // Trash
573    
574                    if (oldStatus == WorkflowConstants.STATUS_IN_TRASH) {
575                            trashEntryLocalService.deleteEntry(
576                                    BookmarksFolder.class.getName(), folder.getFolderId());
577                    }
578                    else if (status == WorkflowConstants.STATUS_IN_TRASH) {
579                            trashEntryLocalService.addTrashEntry(
580                                    userId, folder.getGroupId(), BookmarksFolder.class.getName(),
581                                    folder.getFolderId(), folder.getUuid(), null, oldStatus, null,
582                                    null);
583                    }
584    
585                    // Index
586    
587                    Indexer indexer = IndexerRegistryUtil.nullSafeGetIndexer(
588                            BookmarksFolder.class);
589    
590                    indexer.reindex(folder);
591    
592                    return folder;
593            }
594    
595            protected long getParentFolderId(
596                            BookmarksFolder folder, long parentFolderId)
597                    throws SystemException {
598    
599                    if (parentFolderId ==
600                                    BookmarksFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
601    
602                            return parentFolderId;
603                    }
604    
605                    if (folder.getFolderId() == parentFolderId) {
606                            return folder.getParentFolderId();
607                    }
608    
609                    BookmarksFolder parentFolder =
610                            bookmarksFolderPersistence.fetchByPrimaryKey(parentFolderId);
611    
612                    if ((parentFolder == null) ||
613                            (folder.getGroupId() != parentFolder.getGroupId())) {
614    
615                            return folder.getParentFolderId();
616                    }
617    
618                    List<Long> subfolderIds = new ArrayList<Long>();
619    
620                    getSubfolderIds(
621                            subfolderIds, folder.getGroupId(), folder.getFolderId());
622    
623                    if (subfolderIds.contains(parentFolderId)) {
624                            return folder.getParentFolderId();
625                    }
626    
627                    return parentFolderId;
628            }
629    
630            protected long getParentFolderId(long groupId, long parentFolderId)
631                    throws SystemException {
632    
633                    if (parentFolderId !=
634                                    BookmarksFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
635    
636                            BookmarksFolder parentFolder =
637                                    bookmarksFolderPersistence.fetchByPrimaryKey(parentFolderId);
638    
639                            if ((parentFolder == null) ||
640                                    (groupId != parentFolder.getGroupId())) {
641    
642                                    parentFolderId =
643                                            BookmarksFolderConstants.DEFAULT_PARENT_FOLDER_ID;
644                            }
645                    }
646    
647                    return parentFolderId;
648            }
649    
650            protected void mergeFolders(BookmarksFolder fromFolder, long toFolderId)
651                    throws PortalException, SystemException {
652    
653                    List<BookmarksFolder> folders = bookmarksFolderPersistence.findByG_P(
654                            fromFolder.getGroupId(), fromFolder.getFolderId());
655    
656                    for (BookmarksFolder folder : folders) {
657                            mergeFolders(folder, toFolderId);
658                    }
659    
660                    List<BookmarksEntry> entries = bookmarksEntryPersistence.findByG_F(
661                            fromFolder.getGroupId(), fromFolder.getFolderId());
662    
663                    for (BookmarksEntry entry : entries) {
664                            entry.setFolderId(toFolderId);
665    
666                            bookmarksEntryPersistence.update(entry);
667    
668                            Indexer indexer = IndexerRegistryUtil.nullSafeGetIndexer(
669                                    BookmarksEntry.class);
670    
671                            indexer.reindex(entry);
672                    }
673    
674                    bookmarksFolderLocalService.deleteFolder(fromFolder);
675            }
676    
677            protected void updateDependentStatus(
678                            List<Object> foldersAndEntries, int status)
679                    throws PortalException, SystemException {
680    
681                    for (Object object : foldersAndEntries) {
682                            if (object instanceof BookmarksEntry) {
683                                    BookmarksEntry entry = (BookmarksEntry)object;
684    
685                                    if (status == WorkflowConstants.STATUS_IN_TRASH) {
686    
687                                            // Asset
688    
689                                            assetEntryLocalService.updateVisible(
690                                                    BookmarksEntry.class.getName(), entry.getEntryId(),
691                                                    false);
692    
693                                            if (entry.getStatus() == WorkflowConstants.STATUS_PENDING) {
694                                                    entry.setStatus(WorkflowConstants.STATUS_DRAFT);
695    
696                                                    bookmarksEntryPersistence.update(entry);
697                                            }
698                                    }
699                                    else {
700    
701                                            // Asset
702    
703                                            if (entry.getStatus() ==
704                                                            WorkflowConstants.STATUS_APPROVED) {
705    
706                                                    assetEntryLocalService.updateVisible(
707                                                            BookmarksEntry.class.getName(), entry.getEntryId(),
708                                                            true);
709                                            }
710                                    }
711    
712                                    // Indexer
713    
714                                    Indexer indexer = IndexerRegistryUtil.nullSafeGetIndexer(
715                                            BookmarksEntry.class);
716    
717                                    indexer.reindex(entry);
718                            }
719                            else if (object instanceof BookmarksFolder) {
720                                    BookmarksFolder folder = (BookmarksFolder)object;
721    
722                                    if (folder.isInTrash()) {
723                                            continue;
724                                    }
725    
726                                    // Folders and entries
727    
728                                    List<Object> curFoldersAndEntries = getFoldersAndEntries(
729                                            folder.getGroupId(), folder.getFolderId());
730    
731                                    updateDependentStatus(curFoldersAndEntries, status);
732    
733                                    if (status == WorkflowConstants.STATUS_IN_TRASH) {
734    
735                                            // Asset
736    
737                                            assetEntryLocalService.updateVisible(
738                                                    BookmarksFolder.class.getName(), folder.getFolderId(),
739                                                    false);
740                                    }
741                                    else {
742    
743                                            // Asset
744    
745                                            assetEntryLocalService.updateVisible(
746                                                    BookmarksFolder.class.getName(), folder.getFolderId(),
747                                                    true);
748                                    }
749    
750                                    // Index
751    
752                                    Indexer indexer = IndexerRegistryUtil.nullSafeGetIndexer(
753                                            BookmarksFolder.class);
754    
755                                    indexer.reindex(folder);
756                            }
757                    }
758            }
759    
760            protected void validate(String name) throws PortalException {
761                    if (Validator.isNull(name) || name.contains("\\\\") ||
762                            name.contains("//")) {
763    
764                            throw new FolderNameException();
765                    }
766            }
767    
768    }