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