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.announcements.service.impl;
016    
017    import com.liferay.portal.kernel.exception.PortalException;
018    import com.liferay.portal.kernel.portlet.PortletProvider;
019    import com.liferay.portal.kernel.portlet.PortletProviderUtil;
020    import com.liferay.portal.model.Group;
021    import com.liferay.portal.model.Organization;
022    import com.liferay.portal.model.Role;
023    import com.liferay.portal.model.Team;
024    import com.liferay.portal.model.UserGroup;
025    import com.liferay.portal.security.auth.PrincipalException;
026    import com.liferay.portal.security.permission.ActionKeys;
027    import com.liferay.portal.security.permission.PermissionChecker;
028    import com.liferay.portal.service.permission.GroupPermissionUtil;
029    import com.liferay.portal.service.permission.OrganizationPermissionUtil;
030    import com.liferay.portal.service.permission.PortalPermissionUtil;
031    import com.liferay.portal.service.permission.RolePermissionUtil;
032    import com.liferay.portal.service.permission.UserGroupPermissionUtil;
033    import com.liferay.portal.util.PortalUtil;
034    import com.liferay.portal.util.PortletKeys;
035    import com.liferay.portlet.announcements.constants.AnnouncementsConstants;
036    import com.liferay.portlet.announcements.model.AnnouncementsEntry;
037    import com.liferay.portlet.announcements.service.base.AnnouncementsEntryServiceBaseImpl;
038    import com.liferay.portlet.announcements.service.permission.AnnouncementsEntryPermission;
039    
040    /**
041     * @author Brian Wing Shun Chan
042     */
043    public class AnnouncementsEntryServiceImpl
044            extends AnnouncementsEntryServiceBaseImpl {
045    
046            @Override
047            public AnnouncementsEntry addEntry(
048                            long plid, long classNameId, long classPK, String title,
049                            String content, String url, String type, int displayDateMonth,
050                            int displayDateDay, int displayDateYear, int displayDateHour,
051                            int displayDateMinute, boolean displayImmediately,
052                            int expirationDateMonth, int expirationDateDay,
053                            int expirationDateYear, int expirationDateHour,
054                            int expirationDateMinute, int priority, boolean alert)
055                    throws PortalException {
056    
057                    PermissionChecker permissionChecker = getPermissionChecker();
058    
059                    if (alert) {
060                            String portletId = PortletProviderUtil.getPortletId(
061                                    AnnouncementsConstants.CLASS_NAME_ALERTS_ENTRY,
062                                    PortletProvider.Action.MANAGE);
063    
064                            AnnouncementsEntryPermission.check(
065                                    permissionChecker, plid, portletId, ActionKeys.ADD_ENTRY);
066                    }
067                    else {
068                            String portletId = PortletProviderUtil.getPortletId(
069                                    AnnouncementsEntry.class.getName(),
070                                    PortletProvider.Action.MANAGE);
071    
072                            AnnouncementsEntryPermission.check(
073                                    permissionChecker, plid, portletId, ActionKeys.ADD_ENTRY);
074                    }
075    
076                    if (classNameId == 0) {
077                            if (!PortalPermissionUtil.contains(
078                                            permissionChecker, ActionKeys.ADD_GENERAL_ANNOUNCEMENTS)) {
079    
080                                    throw new PrincipalException.MustHavePermission(
081                                            permissionChecker, PortletKeys.PORTAL, PortletKeys.PORTAL,
082                                            ActionKeys.ADD_GENERAL_ANNOUNCEMENTS);
083                            }
084                    }
085                    else {
086                            String className = PortalUtil.getClassName(classNameId);
087    
088                            if (className.equals(Group.class.getName()) &&
089                                    !GroupPermissionUtil.contains(
090                                            permissionChecker, classPK,
091                                            ActionKeys.MANAGE_ANNOUNCEMENTS)) {
092    
093                                    throw new PrincipalException.MustHavePermission(
094                                            permissionChecker, className, classPK,
095                                            ActionKeys.MANAGE_ANNOUNCEMENTS);
096                            }
097    
098                            if (className.equals(Organization.class.getName()) &&
099                                    !OrganizationPermissionUtil.contains(
100                                            permissionChecker, classPK,
101                                            ActionKeys.MANAGE_ANNOUNCEMENTS)) {
102    
103                                    throw new PrincipalException.MustHavePermission(
104                                            permissionChecker, className, classPK,
105                                            ActionKeys.MANAGE_ANNOUNCEMENTS);
106                            }
107    
108                            if (className.equals(Role.class.getName())) {
109                                    Role role = roleLocalService.getRole(classPK);
110    
111                                    if (role.isTeam()) {
112                                            Team team = teamLocalService.getTeam(role.getClassPK());
113    
114                                            if (!GroupPermissionUtil.contains(
115                                                            permissionChecker, team.getGroupId(),
116                                                            ActionKeys.MANAGE_ANNOUNCEMENTS) ||
117                                                    !RolePermissionUtil.contains(
118                                                            permissionChecker, team.getGroupId(), classPK,
119                                                            ActionKeys.MANAGE_ANNOUNCEMENTS)) {
120    
121                                                    throw new PrincipalException.MustHavePermission(
122                                                            permissionChecker, Team.class.getName(), classPK,
123                                                            ActionKeys.MANAGE_ANNOUNCEMENTS);
124                                            }
125                                    }
126                                    else if (!RolePermissionUtil.contains(
127                                                            permissionChecker, classPK,
128                                                            ActionKeys.MANAGE_ANNOUNCEMENTS)) {
129    
130                                            throw new PrincipalException.MustHavePermission(
131                                                    permissionChecker, className, classPK,
132                                                    ActionKeys.MANAGE_ANNOUNCEMENTS);
133                                    }
134                            }
135    
136                            if (className.equals(UserGroup.class.getName()) &&
137                                    !UserGroupPermissionUtil.contains(
138                                            permissionChecker, classPK,
139                                            ActionKeys.MANAGE_ANNOUNCEMENTS)) {
140    
141                                    throw new PrincipalException.MustHavePermission(
142                                            permissionChecker, className, classPK,
143                                            ActionKeys.MANAGE_ANNOUNCEMENTS);
144                            }
145                    }
146    
147                    return announcementsEntryLocalService.addEntry(
148                            getUserId(), classNameId, classPK, title, content, url, type,
149                            displayDateMonth, displayDateDay, displayDateYear, displayDateHour,
150                            displayDateMinute, displayImmediately, expirationDateMonth,
151                            expirationDateDay, expirationDateYear, expirationDateHour,
152                            expirationDateMinute, priority, alert);
153            }
154    
155            /**
156             * @deprecated As of 6.2.0, replaced by {@link #addEntry(long, long, long,
157             *             String, String, String, String, int, int, int, int, int,
158             *             boolean, int, int, int, int, int, int, boolean)}
159             */
160            @Deprecated
161            @Override
162            public AnnouncementsEntry addEntry(
163                            long plid, long classNameId, long classPK, String title,
164                            String content, String url, String type, int displayDateMonth,
165                            int displayDateDay, int displayDateYear, int displayDateHour,
166                            int displayDateMinute, int expirationDateMonth,
167                            int expirationDateDay, int expirationDateYear,
168                            int expirationDateHour, int expirationDateMinute, int priority,
169                            boolean alert)
170                    throws PortalException {
171    
172                    return addEntry(
173                            plid, classNameId, classPK, title, content, url, type,
174                            displayDateMonth, displayDateDay, displayDateYear, displayDateHour,
175                            displayDateMinute, false, expirationDateMonth, expirationDateDay,
176                            expirationDateYear, expirationDateHour, expirationDateMinute,
177                            priority, alert);
178            }
179    
180            @Override
181            public void deleteEntry(long entryId) throws PortalException {
182                    AnnouncementsEntryPermission.check(
183                            getPermissionChecker(), entryId, ActionKeys.DELETE);
184    
185                    announcementsEntryLocalService.deleteEntry(entryId);
186            }
187    
188            @Override
189            public AnnouncementsEntry getEntry(long entryId) throws PortalException {
190                    AnnouncementsEntry entry = announcementsEntryLocalService.getEntry(
191                            entryId);
192    
193                    AnnouncementsEntryPermission.check(
194                            getPermissionChecker(), entry, ActionKeys.VIEW);
195    
196                    return entry;
197            }
198    
199            @Override
200            public AnnouncementsEntry updateEntry(
201                            long entryId, String title, String content, String url, String type,
202                            int displayDateMonth, int displayDateDay, int displayDateYear,
203                            int displayDateHour, int displayDateMinute,
204                            boolean displayImmediately, int expirationDateMonth,
205                            int expirationDateDay, int expirationDateYear,
206                            int expirationDateHour, int expirationDateMinute, int priority)
207                    throws PortalException {
208    
209                    AnnouncementsEntryPermission.check(
210                            getPermissionChecker(), entryId, ActionKeys.UPDATE);
211    
212                    return announcementsEntryLocalService.updateEntry(
213                            getUserId(), entryId, title, content, url, type, displayDateMonth,
214                            displayDateDay, displayDateYear, displayDateHour, displayDateMinute,
215                            displayImmediately, expirationDateMonth, expirationDateDay,
216                            expirationDateYear, expirationDateHour, expirationDateMinute,
217                            priority);
218            }
219    
220    }