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.findByG_P(
197                            groupId, JournalFolderConstants.DEFAULT_PARENT_FOLDER_ID);
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                    socialActivityCounterLocalService.disableActivityCounters(
449                            JournalFolder.class.getName(), folder.getFolderId());
450    
451                    JSONObject extraDataJSONObject = JSONFactoryUtil.createJSONObject();
452    
453                    extraDataJSONObject.put("title", title);
454    
455                    socialActivityLocalService.addActivity(
456                            userId, folder.getGroupId(), JournalFolder.class.getName(),
457                            folder.getFolderId(), SocialActivityConstants.TYPE_MOVE_TO_TRASH,
458                            extraDataJSONObject.toString(), 0);
459    
460                    return folder;
461            }
462    
463            @Override
464            public void restoreFolderFromTrash(long userId, long folderId)
465                    throws PortalException, SystemException {
466    
467                    JournalFolder folder = journalFolderPersistence.findByPrimaryKey(
468                            folderId);
469    
470                    folder.setName(TrashUtil.getOriginalTitle(folder.getName()));
471    
472                    journalFolderPersistence.update(folder);
473    
474                    TrashEntry trashEntry = trashEntryLocalService.getEntry(
475                            JournalFolder.class.getName(), folderId);
476    
477                    updateStatus(userId, folder, trashEntry.getStatus());
478    
479                    // Social
480    
481                    socialActivityCounterLocalService.enableActivityCounters(
482                            JournalFolder.class.getName(), folder.getFolderId());
483    
484                    JSONObject extraDataJSONObject = JSONFactoryUtil.createJSONObject();
485    
486                    extraDataJSONObject.put("title", folder.getName());
487    
488                    socialActivityLocalService.addActivity(
489                            userId, folder.getGroupId(), JournalFolder.class.getName(),
490                            folder.getFolderId(),
491                            SocialActivityConstants.TYPE_RESTORE_FROM_TRASH,
492                            extraDataJSONObject.toString(), 0);
493            }
494    
495            @Override
496            public void updateAsset(
497                            long userId, JournalFolder folder, long[] assetCategoryIds,
498                            String[] assetTagNames, long[] assetLinkEntryIds)
499                    throws PortalException, SystemException {
500    
501                    AssetEntry assetEntry = assetEntryLocalService.updateEntry(
502                            userId, folder.getGroupId(), folder.getCreateDate(),
503                            folder.getModifiedDate(), JournalFolder.class.getName(),
504                            folder.getFolderId(), folder.getUuid(), 0, assetCategoryIds,
505                            assetTagNames, true, null, null, null, ContentTypes.TEXT_PLAIN,
506                            folder.getName(), folder.getDescription(), null, null, null, 0, 0,
507                            null, false);
508    
509                    assetLinkLocalService.updateLinks(
510                            userId, assetEntry.getEntryId(), assetLinkEntryIds,
511                            AssetLinkConstants.TYPE_RELATED);
512            }
513    
514            @Indexable(type = IndexableType.REINDEX)
515            @Override
516            public JournalFolder updateFolder(
517                            long userId, long folderId, long parentFolderId, String name,
518                            String description, boolean mergeWithParentFolder,
519                            ServiceContext serviceContext)
520                    throws PortalException, SystemException {
521    
522                    // Merge folders
523    
524                    JournalFolder folder = journalFolderPersistence.findByPrimaryKey(
525                            folderId);
526    
527                    parentFolderId = getParentFolderId(folder, parentFolderId);
528    
529                    if (mergeWithParentFolder && (folderId != parentFolderId)) {
530                            mergeFolders(folder, parentFolderId);
531    
532                            return folder;
533                    }
534    
535                    // Folder
536    
537                    validateFolder(folderId, folder.getGroupId(), parentFolderId, name);
538    
539                    folder.setModifiedDate(serviceContext.getModifiedDate(null));
540                    folder.setParentFolderId(parentFolderId);
541                    folder.setName(name);
542                    folder.setDescription(description);
543                    folder.setExpandoBridgeAttributes(serviceContext);
544    
545                    journalFolderPersistence.update(folder);
546    
547                    // Asset
548    
549                    updateAsset(
550                            userId, folder, serviceContext.getAssetCategoryIds(),
551                            serviceContext.getAssetTagNames(),
552                            serviceContext.getAssetLinkEntryIds());
553    
554                    return folder;
555            }
556    
557            @Override
558            public JournalFolder updateStatus(
559                            long userId, JournalFolder folder, int status)
560                    throws PortalException, SystemException {
561    
562                    User user = userPersistence.findByPrimaryKey(userId);
563    
564                    int oldStatus = folder.getStatus();
565    
566                    folder.setStatus(status);
567                    folder.setStatusByUserId(userId);
568                    folder.setStatusByUserName(user.getFullName());
569                    folder.setStatusDate(new Date());
570    
571                    journalFolderPersistence.update(folder);
572    
573                    // Folders and entries
574    
575                    List<Object> foldersAndEntries =
576                            journalFolderLocalService.getFoldersAndArticles(
577                                    folder.getGroupId(), folder.getFolderId());
578    
579                    updateDependentStatus(foldersAndEntries, status);
580    
581                    if (status == WorkflowConstants.STATUS_APPROVED) {
582    
583                            // Asset
584    
585                            assetEntryLocalService.updateVisible(
586                                    JournalFolder.class.getName(), folder.getFolderId(), true);
587    
588                            // Social
589    
590                            socialActivityCounterLocalService.enableActivityCounters(
591                                    JournalFolder.class.getName(), folder.getFolderId());
592                    }
593                    else if (status == WorkflowConstants.STATUS_IN_TRASH) {
594    
595                            // Asset
596    
597                            assetEntryLocalService.updateVisible(
598                                    JournalFolder.class.getName(), folder.getFolderId(), false);
599    
600                            // Social
601    
602                            socialActivityCounterLocalService.disableActivityCounters(
603                                    JournalFolder.class.getName(), folder.getFolderId());
604                    }
605    
606                    // Trash
607    
608                    if (oldStatus == WorkflowConstants.STATUS_IN_TRASH) {
609                            trashEntryLocalService.deleteEntry(
610                                    JournalFolder.class.getName(), folder.getFolderId());
611                    }
612                    else if (status == WorkflowConstants.STATUS_IN_TRASH) {
613                            UnicodeProperties typeSettingsProperties = new UnicodeProperties();
614    
615                            typeSettingsProperties.put("title", folder.getName());
616    
617                            trashEntryLocalService.addTrashEntry(
618                                    userId, folder.getGroupId(), JournalFolder.class.getName(),
619                                    folder.getFolderId(), oldStatus, null, typeSettingsProperties);
620                    }
621    
622                    // Index
623    
624                    Indexer indexer = IndexerRegistryUtil.nullSafeGetIndexer(
625                            JournalFolder.class);
626    
627                    indexer.reindex(folder);
628    
629                    return folder;
630            }
631    
632            protected long getParentFolderId(JournalFolder folder, long parentFolderId)
633                    throws SystemException {
634    
635                    if (parentFolderId == JournalFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
636                            return parentFolderId;
637                    }
638    
639                    if (folder.getFolderId() == parentFolderId) {
640                            return folder.getParentFolderId();
641                    }
642                    else {
643                            JournalFolder parentFolder =
644                                    journalFolderPersistence.fetchByPrimaryKey(parentFolderId);
645    
646                            if ((parentFolder == null) ||
647                                    (folder.getGroupId() != parentFolder.getGroupId())) {
648    
649                                    return folder.getParentFolderId();
650                            }
651    
652                            List<Long> subfolderIds = new ArrayList<Long>();
653    
654                            getSubfolderIds(
655                                    subfolderIds, folder.getGroupId(), folder.getFolderId());
656    
657                            if (subfolderIds.contains(parentFolderId)) {
658                                    return folder.getParentFolderId();
659                            }
660    
661                            return parentFolderId;
662                    }
663            }
664    
665            protected long getParentFolderId(long groupId, long parentFolderId)
666                    throws SystemException {
667    
668                    if (parentFolderId != JournalFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
669                            JournalFolder parentFolder =
670                                    journalFolderPersistence.fetchByPrimaryKey(parentFolderId);
671    
672                            if ((parentFolder == null) ||
673                                    (groupId != parentFolder.getGroupId())) {
674    
675                                    parentFolderId =
676                                            JournalFolderConstants.DEFAULT_PARENT_FOLDER_ID;
677                            }
678                    }
679    
680                    return parentFolderId;
681            }
682    
683            protected void mergeFolders(JournalFolder fromFolder, long toFolderId)
684                    throws PortalException, SystemException {
685    
686                    List<JournalFolder> folders = journalFolderPersistence.findByG_P(
687                            fromFolder.getGroupId(), fromFolder.getFolderId());
688    
689                    for (JournalFolder folder : folders) {
690                            mergeFolders(folder, toFolderId);
691                    }
692    
693                    List<JournalArticle> articles = journalArticlePersistence.findByG_F(
694                            fromFolder.getGroupId(), fromFolder.getFolderId());
695    
696                    for (JournalArticle article : articles) {
697                            article.setFolderId(toFolderId);
698    
699                            journalArticlePersistence.update(article);
700    
701                            Indexer indexer = IndexerRegistryUtil.nullSafeGetIndexer(
702                                    JournalArticle.class);
703    
704                            indexer.reindex(article);
705                    }
706    
707                    journalFolderLocalService.deleteFolder(fromFolder);
708            }
709    
710            protected void updateDependentStatus(
711                            List<Object> foldersAndEntries, int status)
712                    throws PortalException, SystemException {
713    
714                    for (Object object : foldersAndEntries) {
715                            if (object instanceof JournalArticle) {
716                                    JournalArticle article = (JournalArticle)object;
717    
718                                    if (status == WorkflowConstants.STATUS_IN_TRASH) {
719    
720                                            // Asset
721    
722                                            if (article.getStatus() ==
723                                                            WorkflowConstants.STATUS_APPROVED) {
724    
725                                                    assetEntryLocalService.updateVisible(
726                                                            JournalArticle.class.getName(),
727                                                            article.getResourcePrimKey(), false);
728                                            }
729    
730                                            // Social
731    
732                                            socialActivityCounterLocalService.disableActivityCounters(
733                                                    JournalArticle.class.getName(),
734                                                    article.getResourcePrimKey());
735    
736                                            if (article.getStatus() ==
737                                                            WorkflowConstants.STATUS_PENDING) {
738    
739                                                    article.setStatus(WorkflowConstants.STATUS_DRAFT);
740    
741                                                    journalArticlePersistence.update(article);
742                                            }
743                                    }
744                                    else {
745    
746                                            // Asset
747    
748                                            if (article.getStatus() ==
749                                                            WorkflowConstants.STATUS_APPROVED) {
750    
751                                                    assetEntryLocalService.updateVisible(
752                                                            JournalArticle.class.getName(),
753                                                            article.getResourcePrimKey(), true);
754                                            }
755    
756                                            // Social
757    
758                                            socialActivityCounterLocalService.enableActivityCounters(
759                                                    JournalArticle.class.getName(),
760                                                    article.getResourcePrimKey());
761                                    }
762    
763                                    // Workflow
764    
765                                    if (status != WorkflowConstants.STATUS_APPROVED) {
766                                            List<JournalArticle> articleVersions =
767                                                    journalArticlePersistence.findByG_A(
768                                                            article.getGroupId(), article.getArticleId());
769    
770                                            for (JournalArticle curArticle : articleVersions) {
771                                                    if (!curArticle.isPending()) {
772                                                            continue;
773                                                    }
774    
775                                                    curArticle.setStatus(WorkflowConstants.STATUS_DRAFT);
776    
777                                                    journalArticlePersistence.update(curArticle);
778    
779                                                    workflowInstanceLinkLocalService.
780                                                            deleteWorkflowInstanceLink(
781                                                                    curArticle.getCompanyId(),
782                                                                    curArticle.getGroupId(),
783                                                                    JournalArticle.class.getName(),
784                                                                    curArticle.getId());
785                                            }
786                                    }
787    
788                                    // Indexer
789    
790                                    Indexer indexer = IndexerRegistryUtil.nullSafeGetIndexer(
791                                            JournalArticle.class);
792    
793                                    indexer.reindex(article);
794                            }
795                            else if (object instanceof JournalFolder) {
796                                    JournalFolder folder = (JournalFolder)object;
797    
798                                    if (folder.isInTrash()) {
799                                            continue;
800                                    }
801    
802                                    // Folders and articles
803    
804                                    List<Object> curFoldersAndEntries = getFoldersAndArticles(
805                                            folder.getGroupId(), folder.getFolderId());
806    
807                                    updateDependentStatus(curFoldersAndEntries, status);
808    
809                                    if (status == WorkflowConstants.STATUS_IN_TRASH) {
810    
811                                            // Asset
812    
813                                            assetEntryLocalService.updateVisible(
814                                                    JournalFolder.class.getName(), folder.getFolderId(),
815                                                    false);
816    
817                                            // Social
818    
819                                            socialActivityCounterLocalService.disableActivityCounters(
820                                                    JournalFolder.class.getName(), folder.getFolderId());
821                                    }
822                                    else {
823    
824                                            // Asset
825    
826                                            assetEntryLocalService.updateVisible(
827                                                    JournalFolder.class.getName(), folder.getFolderId(),
828                                                    true);
829    
830                                            // Social
831    
832                                            socialActivityCounterLocalService.enableActivityCounters(
833                                                    JournalFolder.class.getName(), folder.getFolderId());
834                                    }
835    
836                                    // Index
837    
838                                    Indexer indexer = IndexerRegistryUtil.nullSafeGetIndexer(
839                                            JournalFolder.class);
840    
841                                    indexer.reindex(folder);
842                            }
843                    }
844            }
845    
846            protected void validateFolder(
847                            long folderId, long groupId, long parentFolderId, String name)
848                    throws PortalException, SystemException {
849    
850                    validateFolderName(name);
851    
852                    JournalFolder folder = journalFolderPersistence.fetchByG_P_N(
853                            groupId, parentFolderId, name);
854    
855                    if ((folder != null) && (folder.getFolderId() != folderId)) {
856                            throw new DuplicateFolderNameException(name);
857                    }
858            }
859    
860            protected void validateFolderName(String name) throws PortalException {
861                    if (!AssetUtil.isValidWord(name)) {
862                            throw new FolderNameException();
863                    }
864    
865                    if (name.contains("\\\\") || name.contains("//")) {
866                            throw new FolderNameException();
867                    }
868            }
869    
870    }