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.journal.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.OrderByComparator;
029    import com.liferay.portal.kernel.util.UnicodeProperties;
030    import com.liferay.portal.kernel.workflow.WorkflowConstants;
031    import com.liferay.portal.model.ResourceConstants;
032    import com.liferay.portal.model.SystemEventConstants;
033    import com.liferay.portal.model.User;
034    import com.liferay.portal.service.ServiceContext;
035    import com.liferay.portal.util.PropsValues;
036    import com.liferay.portlet.asset.model.AssetEntry;
037    import com.liferay.portlet.asset.model.AssetLinkConstants;
038    import com.liferay.portlet.asset.util.AssetUtil;
039    import com.liferay.portlet.journal.DuplicateFolderNameException;
040    import com.liferay.portlet.journal.FolderNameException;
041    import com.liferay.portlet.journal.model.JournalArticle;
042    import com.liferay.portlet.journal.model.JournalFolder;
043    import com.liferay.portlet.journal.model.JournalFolderConstants;
044    import com.liferay.portlet.journal.service.base.JournalFolderLocalServiceBaseImpl;
045    import com.liferay.portlet.social.model.SocialActivityConstants;
046    import com.liferay.portlet.trash.model.TrashEntry;
047    import com.liferay.portlet.trash.util.TrashUtil;
048    
049    import java.util.ArrayList;
050    import java.util.Date;
051    import java.util.List;
052    
053    /**
054     * @author Juan Fern??ndez
055     */
056    public class JournalFolderLocalServiceImpl
057            extends JournalFolderLocalServiceBaseImpl {
058    
059            @Override
060            public JournalFolder addFolder(
061                            long userId, long groupId, long parentFolderId, String name,
062                            String description, ServiceContext serviceContext)
063                    throws PortalException, SystemException {
064    
065                    // Folder
066    
067                    User user = userPersistence.findByPrimaryKey(userId);
068                    parentFolderId = getParentFolderId(groupId, parentFolderId);
069                    Date now = new Date();
070    
071                    validateFolder(0, groupId, parentFolderId, name);
072    
073                    long folderId = counterLocalService.increment();
074    
075                    JournalFolder folder = journalFolderPersistence.create(folderId);
076    
077                    folder.setUuid(serviceContext.getUuid());
078                    folder.setGroupId(groupId);
079                    folder.setCompanyId(user.getCompanyId());
080                    folder.setUserId(user.getUserId());
081                    folder.setUserName(user.getFullName());
082                    folder.setCreateDate(serviceContext.getCreateDate(now));
083                    folder.setModifiedDate(serviceContext.getModifiedDate(now));
084                    folder.setParentFolderId(parentFolderId);
085                    folder.setTreePath(folder.buildTreePath());
086                    folder.setName(name);
087                    folder.setDescription(description);
088                    folder.setExpandoBridgeAttributes(serviceContext);
089    
090                    journalFolderPersistence.update(folder);
091    
092                    // Resources
093    
094                    resourceLocalService.addModelResources(folder, serviceContext);
095    
096                    // Asset
097    
098                    updateAsset(
099                            userId, folder, serviceContext.getAssetCategoryIds(),
100                            serviceContext.getAssetTagNames(),
101                            serviceContext.getAssetLinkEntryIds());
102    
103                    return folder;
104            }
105    
106            @Indexable(type = IndexableType.DELETE)
107            @Override
108            @SystemEvent(
109                    action = SystemEventConstants.ACTION_SKIP, send = false,
110                    type = SystemEventConstants.TYPE_DELETE)
111            public JournalFolder deleteFolder(JournalFolder folder)
112                    throws PortalException, SystemException {
113    
114                    return deleteFolder(folder, true);
115            }
116    
117            @Indexable(type = IndexableType.DELETE)
118            @Override
119            @SystemEvent(
120                    action = SystemEventConstants.ACTION_SKIP, send = false,
121                    type = SystemEventConstants.TYPE_DELETE)
122            public JournalFolder deleteFolder(
123                            JournalFolder folder, boolean includeTrashedEntries)
124                    throws PortalException, SystemException {
125    
126                    // Folders
127    
128                    List<JournalFolder> folders = journalFolderPersistence.findByG_P(
129                            folder.getGroupId(), folder.getFolderId());
130    
131                    for (JournalFolder curFolder : folders) {
132                            if (includeTrashedEntries || !curFolder.isInTrash()) {
133                                    deleteFolder(curFolder);
134                            }
135                    }
136    
137                    // Folder
138    
139                    journalFolderPersistence.remove(folder);
140    
141                    // Resources
142    
143                    resourceLocalService.deleteResource(
144                            folder, ResourceConstants.SCOPE_INDIVIDUAL);
145    
146                    // Entries
147    
148                    journalArticleLocalService.deleteArticles(
149                            folder.getGroupId(), folder.getFolderId(), includeTrashedEntries);
150    
151                    // Asset
152    
153                    assetEntryLocalService.deleteEntry(
154                            JournalFolder.class.getName(), folder.getFolderId());
155    
156                    // Expando
157    
158                    expandoValueLocalService.deleteValues(
159                            JournalFolder.class.getName(), folder.getFolderId());
160    
161                    // Trash
162    
163                    trashEntryLocalService.deleteEntry(
164                            JournalFolder.class.getName(), folder.getFolderId());
165    
166                    return folder;
167            }
168    
169            @Indexable(type = IndexableType.DELETE)
170            @Override
171            public JournalFolder deleteFolder(long folderId)
172                    throws PortalException, SystemException {
173    
174                    JournalFolder folder = journalFolderPersistence.findByPrimaryKey(
175                            folderId);
176    
177                    return journalFolderLocalService.deleteFolder(folder, true);
178            }
179    
180            @Indexable(type = IndexableType.DELETE)
181            @Override
182            public JournalFolder deleteFolder(
183                            long folderId, boolean includeTrashedEntries)
184                    throws PortalException, SystemException {
185    
186                    JournalFolder folder = journalFolderPersistence.findByPrimaryKey(
187                            folderId);
188    
189                    return journalFolderLocalService.deleteFolder(
190                            folder, includeTrashedEntries);
191            }
192    
193            @Override
194            public void deleteFolders(long groupId)
195                    throws PortalException, SystemException {
196    
197                    List<JournalFolder> folders = journalFolderPersistence.findByGroupId(
198                            groupId);
199    
200                    for (JournalFolder folder : folders) {
201                            journalFolderLocalService.deleteFolder(folder);
202                    }
203            }
204    
205            @Override
206            public JournalFolder fetchFolder(long folderId) throws SystemException {
207                    return journalFolderPersistence.fetchByPrimaryKey(folderId);
208            }
209    
210            @Override
211            public JournalFolder fetchFolder(
212                            long groupId, long parentFolderId, String name)
213                    throws SystemException {
214    
215                    return journalFolderPersistence.fetchByG_P_N(
216                                    groupId, parentFolderId, name);
217            }
218    
219            @Override
220            public JournalFolder fetchFolder(long groupId, String name)
221                    throws SystemException {
222    
223                    return journalFolderPersistence.fetchByG_N(groupId, name);
224            }
225    
226            @Override
227            public List<JournalFolder> getCompanyFolders(
228                            long companyId, int start, int end)
229                    throws SystemException {
230    
231                    return journalFolderPersistence.findByCompanyId(companyId, start, end);
232            }
233    
234            @Override
235            public int getCompanyFoldersCount(long companyId) throws SystemException {
236                    return journalFolderPersistence.countByCompanyId(companyId);
237            }
238    
239            @Override
240            public JournalFolder getFolder(long folderId)
241                    throws PortalException, SystemException {
242    
243                    return journalFolderPersistence.findByPrimaryKey(folderId);
244            }
245    
246            @Override
247            public List<JournalFolder> getFolders(long groupId) throws SystemException {
248                    return journalFolderPersistence.findByGroupId(groupId);
249            }
250    
251            @Override
252            public List<JournalFolder> getFolders(long groupId, long parentFolderId)
253                    throws SystemException {
254    
255                    return getFolders(
256                            groupId, parentFolderId, WorkflowConstants.STATUS_APPROVED);
257            }
258    
259            @Override
260            public List<JournalFolder> getFolders(
261                            long groupId, long parentFolderId, int status)
262                    throws SystemException {
263    
264                    return journalFolderPersistence.findByG_P_S(
265                            groupId, parentFolderId, status);
266            }
267    
268            @Override
269            public List<JournalFolder> getFolders(
270                            long groupId, long parentFolderId, int start, int end)
271                    throws SystemException {
272    
273                    return getFolders(
274                            groupId, parentFolderId, WorkflowConstants.STATUS_APPROVED, start,
275                            end);
276            }
277    
278            @Override
279            public List<JournalFolder> getFolders(
280                            long groupId, long parentFolderId, int status, int start, int end)
281                    throws SystemException {
282    
283                    return journalFolderPersistence.findByG_P_S(
284                                    groupId, parentFolderId, status, start, end);
285            }
286    
287            @Override
288            public List<Object> getFoldersAndArticles(long groupId, long folderId)
289                    throws SystemException {
290    
291                    QueryDefinition queryDefinition = new QueryDefinition(
292                            WorkflowConstants.STATUS_ANY);
293    
294                    return journalFolderFinder.findF_A_ByG_F(
295                            groupId, folderId, queryDefinition);
296            }
297    
298            @Override
299            public List<Object> getFoldersAndArticles(
300                            long groupId, long folderId, int start, int end,
301                            OrderByComparator obc)
302                    throws SystemException {
303    
304                    QueryDefinition queryDefinition = new QueryDefinition(
305                            WorkflowConstants.STATUS_ANY, start, end, obc);
306    
307                    return journalFolderFinder.findF_A_ByG_F(
308                            groupId, folderId, queryDefinition);
309            }
310    
311            @Override
312            public int getFoldersAndArticlesCount(
313                            long groupId, List<Long> folderIds, int status)
314                    throws SystemException {
315    
316                    QueryDefinition queryDefinition = new QueryDefinition(status);
317    
318                    if (folderIds.size() <= PropsValues.SQL_DATA_MAX_PARAMETERS) {
319                            return journalArticleFinder.countByG_F(
320                                    groupId, folderIds, queryDefinition);
321                    }
322                    else {
323                            int start = 0;
324                            int end = PropsValues.SQL_DATA_MAX_PARAMETERS;
325    
326                            int articlesCount = journalArticleFinder.countByG_F(
327                                    groupId, folderIds.subList(start, end), queryDefinition);
328    
329                            folderIds.subList(start, end).clear();
330    
331                            articlesCount += getFoldersAndArticlesCount(
332                                    groupId, folderIds, status);
333    
334                            return articlesCount;
335                    }
336            }
337    
338            @Override
339            public int getFoldersAndArticlesCount(long groupId, long folderId)
340                    throws SystemException {
341    
342                    return journalFolderFinder.countF_A_ByG_F(
343                            groupId, folderId,
344                            new QueryDefinition(WorkflowConstants.STATUS_ANY));
345            }
346    
347            @Override
348            public int getFoldersCount(long groupId, long parentFolderId)
349                    throws SystemException {
350    
351                    return getFoldersCount(
352                            groupId, parentFolderId, WorkflowConstants.STATUS_APPROVED);
353            }
354    
355            @Override
356            public int getFoldersCount(long groupId, long parentFolderId, int status)
357                    throws SystemException {
358    
359                    return journalFolderPersistence.countByG_P_S(
360                            groupId, parentFolderId, status);
361            }
362    
363            @Override
364            public List<JournalFolder> getNoAssetFolders() throws SystemException {
365                    return journalFolderFinder.findF_ByNoAssets();
366            }
367    
368            @Override
369            public void getSubfolderIds(
370                            List<Long> folderIds, long groupId, long folderId)
371                    throws SystemException {
372    
373                    List<JournalFolder> folders = journalFolderPersistence.findByG_P(
374                            groupId, folderId);
375    
376                    for (JournalFolder folder : folders) {
377                            folderIds.add(folder.getFolderId());
378    
379                            getSubfolderIds(
380                                    folderIds, folder.getGroupId(), folder.getFolderId());
381                    }
382            }
383    
384            @Indexable(type = IndexableType.REINDEX)
385            @Override
386            public JournalFolder moveFolder(
387                            long folderId, long parentFolderId, ServiceContext serviceContext)
388                    throws PortalException, SystemException {
389    
390                    JournalFolder folder = journalFolderPersistence.findByPrimaryKey(
391                            folderId);
392    
393                    parentFolderId = getParentFolderId(folder, parentFolderId);
394    
395                    validateFolder(
396                            folder.getFolderId(), folder.getGroupId(), parentFolderId,
397                            folder.getName());
398    
399                    folder.setModifiedDate(serviceContext.getModifiedDate(null));
400                    folder.setParentFolderId(parentFolderId);
401                    folder.setTreePath(folder.buildTreePath());
402                    folder.setExpandoBridgeAttributes(serviceContext);
403    
404                    journalFolderPersistence.update(folder);
405    
406                    return folder;
407            }
408    
409            @Override
410            public JournalFolder moveFolderFromTrash(
411                            long userId, long folderId, long parentFolderId,
412                            ServiceContext serviceContext)
413                    throws PortalException, SystemException {
414    
415                    JournalFolder folder = journalFolderPersistence.findByPrimaryKey(
416                            folderId);
417    
418                    if (folder.isInTrash()) {
419                            restoreFolderFromTrash(userId, folderId);
420                    }
421                    else {
422                            updateStatus(userId, folder, WorkflowConstants.STATUS_APPROVED);
423                    }
424    
425                    return journalFolderLocalService.moveFolder(
426                            folderId, parentFolderId, serviceContext);
427            }
428    
429            @Override
430            public JournalFolder moveFolderToTrash(long userId, long folderId)
431                    throws PortalException, SystemException {
432    
433                    JournalFolder folder = journalFolderPersistence.findByPrimaryKey(
434                            folderId);
435    
436                    String title = folder.getName();
437    
438                    folder = updateStatus(
439                            userId, folder, WorkflowConstants.STATUS_IN_TRASH);
440    
441                    TrashEntry trashEntry = trashEntryLocalService.getEntry(
442                            JournalFolder.class.getName(), folder.getFolderId());
443    
444                    folder.setName(TrashUtil.getTrashTitle(trashEntry.getEntryId()));
445    
446                    journalFolderPersistence.update(folder);
447    
448                    // Social
449    
450                    JSONObject extraDataJSONObject = JSONFactoryUtil.createJSONObject();
451    
452                    extraDataJSONObject.put("title", title);
453    
454                    socialActivityLocalService.addActivity(
455                            userId, folder.getGroupId(), JournalFolder.class.getName(),
456                            folder.getFolderId(), SocialActivityConstants.TYPE_MOVE_TO_TRASH,
457                            extraDataJSONObject.toString(), 0);
458    
459                    return folder;
460            }
461    
462            @Override
463            public void rebuildTree(long companyId)
464                    throws PortalException, SystemException {
465    
466                    List<JournalFolder> folders = journalFolderPersistence.findByC_NotS(
467                            companyId, WorkflowConstants.STATUS_IN_TRASH);
468    
469                    for (JournalFolder folder : folders) {
470                            if (folder.isInTrashContainer()) {
471                                    continue;
472                            }
473    
474                            folder.setTreePath(folder.buildTreePath());
475    
476                            journalFolderPersistence.update(folder);
477                    }
478            }
479    
480            @Override
481            public void restoreFolderFromTrash(long userId, long folderId)
482                    throws PortalException, SystemException {
483    
484                    JournalFolder folder = journalFolderPersistence.findByPrimaryKey(
485                            folderId);
486    
487                    folder.setName(TrashUtil.getOriginalTitle(folder.getName()));
488    
489                    journalFolderPersistence.update(folder);
490    
491                    TrashEntry trashEntry = trashEntryLocalService.getEntry(
492                            JournalFolder.class.getName(), folderId);
493    
494                    updateStatus(userId, folder, trashEntry.getStatus());
495    
496                    // Social
497    
498                    JSONObject extraDataJSONObject = JSONFactoryUtil.createJSONObject();
499    
500                    extraDataJSONObject.put("title", folder.getName());
501    
502                    socialActivityLocalService.addActivity(
503                            userId, folder.getGroupId(), JournalFolder.class.getName(),
504                            folder.getFolderId(),
505                            SocialActivityConstants.TYPE_RESTORE_FROM_TRASH,
506                            extraDataJSONObject.toString(), 0);
507            }
508    
509            @Override
510            public void updateAsset(
511                            long userId, JournalFolder folder, long[] assetCategoryIds,
512                            String[] assetTagNames, long[] assetLinkEntryIds)
513                    throws PortalException, SystemException {
514    
515                    AssetEntry assetEntry = assetEntryLocalService.updateEntry(
516                            userId, folder.getGroupId(), folder.getCreateDate(),
517                            folder.getModifiedDate(), JournalFolder.class.getName(),
518                            folder.getFolderId(), folder.getUuid(), 0, assetCategoryIds,
519                            assetTagNames, true, null, null, null, ContentTypes.TEXT_PLAIN,
520                            folder.getName(), folder.getDescription(), null, null, null, 0, 0,
521                            null, false);
522    
523                    assetLinkLocalService.updateLinks(
524                            userId, assetEntry.getEntryId(), assetLinkEntryIds,
525                            AssetLinkConstants.TYPE_RELATED);
526            }
527    
528            @Indexable(type = IndexableType.REINDEX)
529            @Override
530            public JournalFolder updateFolder(
531                            long userId, long folderId, long parentFolderId, String name,
532                            String description, boolean mergeWithParentFolder,
533                            ServiceContext serviceContext)
534                    throws PortalException, SystemException {
535    
536                    // Merge folders
537    
538                    JournalFolder folder = journalFolderPersistence.findByPrimaryKey(
539                            folderId);
540    
541                    parentFolderId = getParentFolderId(folder, parentFolderId);
542    
543                    if (mergeWithParentFolder && (folderId != parentFolderId)) {
544                            mergeFolders(folder, parentFolderId);
545    
546                            return folder;
547                    }
548    
549                    // Folder
550    
551                    validateFolder(folderId, folder.getGroupId(), parentFolderId, name);
552    
553                    folder.setModifiedDate(serviceContext.getModifiedDate(null));
554                    folder.setParentFolderId(parentFolderId);
555                    folder.setTreePath(folder.buildTreePath());
556                    folder.setName(name);
557                    folder.setDescription(description);
558                    folder.setExpandoBridgeAttributes(serviceContext);
559    
560                    journalFolderPersistence.update(folder);
561    
562                    // Asset
563    
564                    updateAsset(
565                            userId, folder, serviceContext.getAssetCategoryIds(),
566                            serviceContext.getAssetTagNames(),
567                            serviceContext.getAssetLinkEntryIds());
568    
569                    return folder;
570            }
571    
572            @Override
573            public JournalFolder updateStatus(
574                            long userId, JournalFolder folder, int status)
575                    throws PortalException, SystemException {
576    
577                    User user = userPersistence.findByPrimaryKey(userId);
578    
579                    int oldStatus = folder.getStatus();
580    
581                    folder.setStatus(status);
582                    folder.setStatusByUserId(userId);
583                    folder.setStatusByUserName(user.getFullName());
584                    folder.setStatusDate(new Date());
585    
586                    journalFolderPersistence.update(folder);
587    
588                    // Folders and entries
589    
590                    List<Object> foldersAndEntries =
591                            journalFolderLocalService.getFoldersAndArticles(
592                                    folder.getGroupId(), folder.getFolderId());
593    
594                    updateDependentStatus(foldersAndEntries, status);
595    
596                    if (status == WorkflowConstants.STATUS_APPROVED) {
597    
598                            // Asset
599    
600                            assetEntryLocalService.updateVisible(
601                                    JournalFolder.class.getName(), folder.getFolderId(), true);
602                    }
603                    else if (status == WorkflowConstants.STATUS_IN_TRASH) {
604    
605                            // Asset
606    
607                            assetEntryLocalService.updateVisible(
608                                    JournalFolder.class.getName(), folder.getFolderId(), false);
609                    }
610    
611                    // Trash
612    
613                    if (oldStatus == WorkflowConstants.STATUS_IN_TRASH) {
614                            trashEntryLocalService.deleteEntry(
615                                    JournalFolder.class.getName(), folder.getFolderId());
616                    }
617                    else if (status == WorkflowConstants.STATUS_IN_TRASH) {
618                            UnicodeProperties typeSettingsProperties = new UnicodeProperties();
619    
620                            typeSettingsProperties.put("title", folder.getName());
621    
622                            trashEntryLocalService.addTrashEntry(
623                                    userId, folder.getGroupId(), JournalFolder.class.getName(),
624                                    folder.getFolderId(), folder.getUuid(), null, oldStatus, null,
625                                    typeSettingsProperties);
626                    }
627    
628                    // Index
629    
630                    Indexer indexer = IndexerRegistryUtil.nullSafeGetIndexer(
631                            JournalFolder.class);
632    
633                    indexer.reindex(folder);
634    
635                    return folder;
636            }
637    
638            protected long getParentFolderId(JournalFolder folder, long parentFolderId)
639                    throws SystemException {
640    
641                    if (parentFolderId == JournalFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
642                            return parentFolderId;
643                    }
644    
645                    if (folder.getFolderId() == parentFolderId) {
646                            return folder.getParentFolderId();
647                    }
648    
649                    JournalFolder parentFolder = journalFolderPersistence.fetchByPrimaryKey(
650                            parentFolderId);
651    
652                    if ((parentFolder == null) ||
653                            (folder.getGroupId() != parentFolder.getGroupId())) {
654    
655                            return folder.getParentFolderId();
656                    }
657    
658                    List<Long> subfolderIds = new ArrayList<Long>();
659    
660                    getSubfolderIds(
661                            subfolderIds, folder.getGroupId(), folder.getFolderId());
662    
663                    if (subfolderIds.contains(parentFolderId)) {
664                            return folder.getParentFolderId();
665                    }
666    
667                    return parentFolderId;
668            }
669    
670            protected long getParentFolderId(long groupId, long parentFolderId)
671                    throws SystemException {
672    
673                    if (parentFolderId != JournalFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
674                            JournalFolder parentFolder =
675                                    journalFolderPersistence.fetchByPrimaryKey(parentFolderId);
676    
677                            if ((parentFolder == null) ||
678                                    (groupId != parentFolder.getGroupId())) {
679    
680                                    parentFolderId =
681                                            JournalFolderConstants.DEFAULT_PARENT_FOLDER_ID;
682                            }
683                    }
684    
685                    return parentFolderId;
686            }
687    
688            protected void mergeFolders(JournalFolder fromFolder, long toFolderId)
689                    throws PortalException, SystemException {
690    
691                    List<JournalFolder> folders = journalFolderPersistence.findByG_P(
692                            fromFolder.getGroupId(), fromFolder.getFolderId());
693    
694                    for (JournalFolder folder : folders) {
695                            mergeFolders(folder, toFolderId);
696                    }
697    
698                    List<JournalArticle> articles = journalArticlePersistence.findByG_F(
699                            fromFolder.getGroupId(), fromFolder.getFolderId());
700    
701                    for (JournalArticle article : articles) {
702                            article.setFolderId(toFolderId);
703    
704                            journalArticlePersistence.update(article);
705    
706                            Indexer indexer = IndexerRegistryUtil.nullSafeGetIndexer(
707                                    JournalArticle.class);
708    
709                            indexer.reindex(article);
710                    }
711    
712                    journalFolderLocalService.deleteFolder(fromFolder);
713            }
714    
715            protected void updateDependentStatus(
716                            List<Object> foldersAndEntries, int status)
717                    throws PortalException, SystemException {
718    
719                    for (Object object : foldersAndEntries) {
720                            if (object instanceof JournalArticle) {
721                                    JournalArticle article = (JournalArticle)object;
722    
723                                    if (status == WorkflowConstants.STATUS_IN_TRASH) {
724    
725                                            // Asset
726    
727                                            if (article.getStatus() ==
728                                                            WorkflowConstants.STATUS_APPROVED) {
729    
730                                                    assetEntryLocalService.updateVisible(
731                                                            JournalArticle.class.getName(),
732                                                            article.getResourcePrimKey(), false);
733                                            }
734    
735                                            if (article.getStatus() ==
736                                                            WorkflowConstants.STATUS_PENDING) {
737    
738                                                    article.setStatus(WorkflowConstants.STATUS_DRAFT);
739    
740                                                    journalArticlePersistence.update(article);
741                                            }
742                                    }
743                                    else {
744    
745                                            // Asset
746    
747                                            if (article.getStatus() ==
748                                                            WorkflowConstants.STATUS_APPROVED) {
749    
750                                                    assetEntryLocalService.updateVisible(
751                                                            JournalArticle.class.getName(),
752                                                            article.getResourcePrimKey(), true);
753                                            }
754                                    }
755    
756                                    // Workflow
757    
758                                    if (status != WorkflowConstants.STATUS_APPROVED) {
759                                            List<JournalArticle> articleVersions =
760                                                    journalArticlePersistence.findByG_A(
761                                                            article.getGroupId(), article.getArticleId());
762    
763                                            for (JournalArticle curArticle : articleVersions) {
764                                                    if (!curArticle.isPending()) {
765                                                            continue;
766                                                    }
767    
768                                                    curArticle.setStatus(WorkflowConstants.STATUS_DRAFT);
769    
770                                                    journalArticlePersistence.update(curArticle);
771    
772                                                    workflowInstanceLinkLocalService.
773                                                            deleteWorkflowInstanceLink(
774                                                                    curArticle.getCompanyId(),
775                                                                    curArticle.getGroupId(),
776                                                                    JournalArticle.class.getName(),
777                                                                    curArticle.getId());
778                                            }
779                                    }
780    
781                                    // Indexer
782    
783                                    Indexer indexer = IndexerRegistryUtil.nullSafeGetIndexer(
784                                            JournalArticle.class);
785    
786                                    indexer.reindex(article);
787                            }
788                            else if (object instanceof JournalFolder) {
789                                    JournalFolder folder = (JournalFolder)object;
790    
791                                    if (folder.isInTrash()) {
792                                            continue;
793                                    }
794    
795                                    // Folders and articles
796    
797                                    List<Object> curFoldersAndEntries = getFoldersAndArticles(
798                                            folder.getGroupId(), folder.getFolderId());
799    
800                                    updateDependentStatus(curFoldersAndEntries, status);
801    
802                                    if (status == WorkflowConstants.STATUS_IN_TRASH) {
803    
804                                            // Asset
805    
806                                            assetEntryLocalService.updateVisible(
807                                                    JournalFolder.class.getName(), folder.getFolderId(),
808                                                    false);
809                                    }
810                                    else {
811    
812                                            // Asset
813    
814                                            assetEntryLocalService.updateVisible(
815                                                    JournalFolder.class.getName(), folder.getFolderId(),
816                                                    true);
817                                    }
818    
819                                    // Index
820    
821                                    Indexer indexer = IndexerRegistryUtil.nullSafeGetIndexer(
822                                            JournalFolder.class);
823    
824                                    indexer.reindex(folder);
825                            }
826                    }
827            }
828    
829            protected void validateFolder(
830                            long folderId, long groupId, long parentFolderId, String name)
831                    throws PortalException, SystemException {
832    
833                    validateFolderName(name);
834    
835                    JournalFolder folder = journalFolderPersistence.fetchByG_P_N(
836                            groupId, parentFolderId, name);
837    
838                    if ((folder != null) && (folder.getFolderId() != folderId)) {
839                            throw new DuplicateFolderNameException(name);
840                    }
841            }
842    
843            protected void validateFolderName(String name) throws PortalException {
844                    if (!AssetUtil.isValidWord(name)) {
845                            throw new FolderNameException();
846                    }
847    
848                    if (name.contains("\\\\") || name.contains("//")) {
849                            throw new FolderNameException();
850                    }
851            }
852    
853    }