001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.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.util.ListUtil;
020    import com.liferay.portal.kernel.util.OrderByComparator;
021    import com.liferay.portal.kernel.workflow.WorkflowConstants;
022    import com.liferay.portal.security.permission.ActionKeys;
023    import com.liferay.portal.security.permission.PermissionChecker;
024    import com.liferay.portal.service.ServiceContext;
025    import com.liferay.portal.util.PropsValues;
026    import com.liferay.portlet.dynamicdatamapping.model.DDMStructure;
027    import com.liferay.portlet.dynamicdatamapping.service.permission.DDMStructurePermission;
028    import com.liferay.portlet.journal.model.JournalArticle;
029    import com.liferay.portlet.journal.model.JournalFolder;
030    import com.liferay.portlet.journal.service.base.JournalFolderServiceBaseImpl;
031    import com.liferay.portlet.journal.service.permission.JournalFolderPermission;
032    
033    import java.util.ArrayList;
034    import java.util.Iterator;
035    import java.util.List;
036    
037    /**
038     * @author Juan Fern??ndez
039     */
040    public class JournalFolderServiceImpl extends JournalFolderServiceBaseImpl {
041    
042            @Override
043            public JournalFolder addFolder(
044                            long groupId, long parentFolderId, String name, String description,
045                            ServiceContext serviceContext)
046                    throws PortalException {
047    
048                    JournalFolderPermission.check(
049                            getPermissionChecker(), groupId, parentFolderId,
050                            ActionKeys.ADD_FOLDER);
051    
052                    return journalFolderLocalService.addFolder(
053                            getUserId(), groupId, parentFolderId, name, description,
054                            serviceContext);
055            }
056    
057            @Override
058            public void deleteFolder(long folderId) throws PortalException {
059                    JournalFolder folder = journalFolderLocalService.getFolder(folderId);
060    
061                    JournalFolderPermission.check(
062                            getPermissionChecker(), folder, ActionKeys.DELETE);
063    
064                    journalFolderLocalService.deleteFolder(folderId);
065            }
066    
067            @Override
068            public void deleteFolder(long folderId, boolean includeTrashedEntries)
069                    throws PortalException {
070    
071                    JournalFolder folder = journalFolderLocalService.getFolder(folderId);
072    
073                    JournalFolderPermission.check(
074                            getPermissionChecker(), folder, ActionKeys.DELETE);
075    
076                    journalFolderLocalService.deleteFolder(folderId, includeTrashedEntries);
077            }
078    
079            @Override
080            public JournalFolder fetchFolder(long folderId) throws PortalException {
081                    JournalFolder folder = journalFolderLocalService.fetchFolder(folderId);
082    
083                    if (folder != null) {
084                            JournalFolderPermission.check(
085                                    getPermissionChecker(), folder, ActionKeys.VIEW);
086                    }
087    
088                    return folder;
089            }
090    
091            @Override
092            public List<DDMStructure> getDDMStructures(
093                            long[] groupIds, long folderId, int restrictionType)
094                    throws PortalException {
095    
096                    return filterStructures(
097                            journalFolderLocalService.getDDMStructures(
098                                    groupIds, folderId, restrictionType));
099            }
100    
101            @Override
102            public JournalFolder getFolder(long folderId) throws PortalException {
103                    JournalFolder folder = journalFolderLocalService.getFolder(folderId);
104    
105                    JournalFolderPermission.check(
106                            getPermissionChecker(), folder, ActionKeys.VIEW);
107    
108                    return folder;
109            }
110    
111            @Override
112            public List<Long> getFolderIds(long groupId, long folderId)
113                    throws PortalException {
114    
115                    JournalFolderPermission.check(
116                            getPermissionChecker(), groupId, folderId, ActionKeys.VIEW);
117    
118                    List<Long> folderIds = getSubfolderIds(groupId, folderId, true);
119    
120                    folderIds.add(0, folderId);
121    
122                    return folderIds;
123            }
124    
125            @Override
126            public List<JournalFolder> getFolders(long groupId) {
127                    return journalFolderPersistence.filterFindByGroupId(groupId);
128            }
129    
130            @Override
131            public List<JournalFolder> getFolders(long groupId, long parentFolderId) {
132                    return getFolders(
133                            groupId, parentFolderId, WorkflowConstants.STATUS_APPROVED);
134            }
135    
136            @Override
137            public List<JournalFolder> getFolders(
138                    long groupId, long parentFolderId, int status) {
139    
140                    return journalFolderPersistence.filterFindByG_P_S(
141                            groupId, parentFolderId, status);
142            }
143    
144            @Override
145            public List<JournalFolder> getFolders(
146                    long groupId, long parentFolderId, int start, int end) {
147    
148                    return getFolders(
149                            groupId, parentFolderId, WorkflowConstants.STATUS_APPROVED, start,
150                            end);
151            }
152    
153            @Override
154            public List<JournalFolder> getFolders(
155                    long groupId, long parentFolderId, int status, int start, int end) {
156    
157                    return journalFolderPersistence.filterFindByG_P_S(
158                            groupId, parentFolderId, status, start, end);
159            }
160    
161            @Override
162            public List<Object> getFoldersAndArticles(
163                    long groupId, long folderId, int status, int start, int end,
164                    OrderByComparator<?> obc) {
165    
166                    QueryDefinition<?> queryDefinition = new QueryDefinition<>(
167                            status, start, end, (OrderByComparator<Object>)obc);
168    
169                    return journalFolderFinder.filterFindF_A_ByG_F(
170                            groupId, folderId, queryDefinition);
171            }
172    
173            @Override
174            public List<Object> getFoldersAndArticles(
175                    long groupId, long folderId, int start, int end,
176                    OrderByComparator<?> obc) {
177    
178                    return getFoldersAndArticles(
179                            groupId, folderId, WorkflowConstants.STATUS_ANY, start, end, obc);
180            }
181    
182            @Override
183            public int getFoldersAndArticlesCount(
184                    long groupId, List<Long> folderIds, int status) {
185    
186                    QueryDefinition<JournalArticle> queryDefinition = new QueryDefinition<>(
187                            status);
188    
189                    if (folderIds.size() <= PropsValues.SQL_DATA_MAX_PARAMETERS) {
190                            return journalArticleFinder.filterCountByG_F(
191                                    groupId, folderIds, queryDefinition);
192                    }
193                    else {
194                            int start = 0;
195                            int end = PropsValues.SQL_DATA_MAX_PARAMETERS;
196    
197                            int articlesCount = journalArticleFinder.filterCountByG_F(
198                                    groupId, folderIds.subList(start, end), queryDefinition);
199    
200                            folderIds.subList(start, end).clear();
201    
202                            articlesCount += getFoldersAndArticlesCount(
203                                    groupId, folderIds, status);
204    
205                            return articlesCount;
206                    }
207            }
208    
209            @Override
210            public int getFoldersAndArticlesCount(long groupId, long folderId) {
211                    return getFoldersAndArticlesCount(
212                            groupId, folderId, WorkflowConstants.STATUS_ANY);
213            }
214    
215            @Override
216            public int getFoldersAndArticlesCount(
217                    long groupId, long folderId, int status) {
218    
219                    return journalFolderFinder.filterCountF_A_ByG_F(
220                            groupId, folderId, new QueryDefinition<Object>(status));
221            }
222    
223            @Override
224            public int getFoldersCount(long groupId, long parentFolderId) {
225                    return getFoldersCount(
226                            groupId, parentFolderId, WorkflowConstants.STATUS_APPROVED);
227            }
228    
229            @Override
230            public int getFoldersCount(long groupId, long parentFolderId, int status) {
231                    if (status == WorkflowConstants.STATUS_ANY) {
232                            return journalFolderPersistence.filterCountByG_P_NotS(
233                                    groupId, parentFolderId, WorkflowConstants.STATUS_IN_TRASH);
234                    }
235                    else {
236                            return journalFolderPersistence.filterCountByG_P_S(
237                                    groupId, parentFolderId, status);
238                    }
239            }
240    
241            /**
242             * @deprecated As of 7.0.0, replaced by {@link #getSubfolderIds(List, long,
243             *             long, boolean)}
244             */
245            @Deprecated
246            @Override
247            public void getSubfolderIds(
248                    List<Long> folderIds, long groupId, long folderId) {
249    
250                    getSubfolderIds(folderIds, groupId, folderId, true);
251            }
252    
253            @Override
254            public void getSubfolderIds(
255                    List<Long> folderIds, long groupId, long folderId, boolean recurse) {
256    
257                    List<JournalFolder> folders =
258                            journalFolderPersistence.filterFindByG_P_NotS(
259                                    groupId, folderId, WorkflowConstants.STATUS_IN_TRASH);
260    
261                    for (JournalFolder folder : folders) {
262                            folderIds.add(folder.getFolderId());
263    
264                            if (recurse) {
265                                    getSubfolderIds(
266                                            folderIds, folder.getGroupId(), folder.getFolderId(),
267                                            recurse);
268                            }
269                    }
270            }
271    
272            @Override
273            public List<Long> getSubfolderIds(
274                    long groupId, long folderId, boolean recurse) {
275    
276                    List<Long> folderIds = new ArrayList<>();
277    
278                    getSubfolderIds(folderIds, groupId, folderId, recurse);
279    
280                    return folderIds;
281            }
282    
283            @Override
284            public JournalFolder moveFolder(
285                            long folderId, long parentFolderId, ServiceContext serviceContext)
286                    throws PortalException {
287    
288                    JournalFolder folder = journalFolderLocalService.getFolder(folderId);
289    
290                    JournalFolderPermission.check(
291                            getPermissionChecker(), folder, ActionKeys.UPDATE);
292    
293                    return journalFolderLocalService.moveFolder(
294                            folderId, parentFolderId, serviceContext);
295            }
296    
297            @Override
298            public JournalFolder moveFolderFromTrash(
299                            long folderId, long parentFolderId, ServiceContext serviceContext)
300                    throws PortalException {
301    
302                    JournalFolder folder = journalFolderLocalService.getFolder(folderId);
303    
304                    JournalFolderPermission.check(
305                            getPermissionChecker(), folder, ActionKeys.UPDATE);
306    
307                    return journalFolderLocalService.moveFolderFromTrash(
308                            getUserId(), folderId, parentFolderId, serviceContext);
309            }
310    
311            @Override
312            public JournalFolder moveFolderToTrash(long folderId)
313                    throws PortalException {
314    
315                    JournalFolder folder = journalFolderLocalService.getFolder(folderId);
316    
317                    JournalFolderPermission.check(
318                            getPermissionChecker(), folder, ActionKeys.DELETE);
319    
320                    return journalFolderLocalService.moveFolderToTrash(
321                            getUserId(), folderId);
322            }
323    
324            @Override
325            public void restoreFolderFromTrash(long folderId) throws PortalException {
326                    JournalFolder folder = journalFolderLocalService.getFolder(folderId);
327    
328                    JournalFolderPermission.check(
329                            getPermissionChecker(), folder, ActionKeys.UPDATE);
330    
331                    journalFolderLocalService.restoreFolderFromTrash(getUserId(), folderId);
332            }
333    
334            @Override
335            public void subscribe(long groupId, long folderId) throws PortalException {
336                    JournalFolderPermission.check(
337                            getPermissionChecker(), groupId, folderId, ActionKeys.SUBSCRIBE);
338    
339                    journalFolderLocalService.subscribe(getUserId(), groupId, folderId);
340            }
341    
342            @Override
343            public void unsubscribe(long groupId, long folderId)
344                    throws PortalException {
345    
346                    JournalFolderPermission.check(
347                            getPermissionChecker(), groupId, folderId, ActionKeys.SUBSCRIBE);
348    
349                    journalFolderLocalService.unsubscribe(getUserId(), groupId, folderId);
350            }
351    
352            @Override
353            public JournalFolder updateFolder(
354                            long groupId, long folderId, long parentFolderId, String name,
355                            String description, boolean mergeWithParentFolder,
356                            ServiceContext serviceContext)
357                    throws PortalException {
358    
359                    JournalFolder folder = journalFolderLocalService.getFolder(folderId);
360    
361                    JournalFolderPermission.check(
362                            getPermissionChecker(), folder, ActionKeys.UPDATE);
363    
364                    return journalFolderLocalService.updateFolder(
365                            getUserId(), groupId, folderId, parentFolderId, name, description,
366                            mergeWithParentFolder, serviceContext);
367            }
368    
369            @Override
370            public JournalFolder updateFolder(
371                            long groupId, long folderId, long parentFolderId, String name,
372                            String description, long[] ddmStructureIds, int restrictionType,
373                            boolean mergeWithParentFolder, ServiceContext serviceContext)
374                    throws PortalException {
375    
376                    JournalFolderPermission.check(
377                            getPermissionChecker(), groupId, folderId, ActionKeys.UPDATE);
378    
379                    return journalFolderLocalService.updateFolder(
380                            getUserId(), groupId, folderId, parentFolderId, name, description,
381                            ddmStructureIds, restrictionType, mergeWithParentFolder,
382                            serviceContext);
383            }
384    
385            protected List<DDMStructure> filterStructures(
386                            List<DDMStructure> ddmStructures)
387                    throws PortalException {
388    
389                    PermissionChecker permissionChecker = getPermissionChecker();
390    
391                    ddmStructures = ListUtil.copy(ddmStructures);
392    
393                    Iterator<DDMStructure> itr = ddmStructures.iterator();
394    
395                    while (itr.hasNext()) {
396                            DDMStructure ddmStructure = itr.next();
397    
398                            if (!DDMStructurePermission.contains(
399                                            permissionChecker, ddmStructure, ActionKeys.VIEW)) {
400    
401                                    itr.remove();
402                            }
403                    }
404    
405                    return ddmStructures;
406            }
407    
408    }