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.util;
016    
017    import com.liferay.portal.kernel.exception.PortalException;
018    import com.liferay.portal.kernel.util.GetterUtil;
019    import com.liferay.portal.kernel.util.PropsKeys;
020    import com.liferay.portal.kernel.util.PropsUtil;
021    import com.liferay.portal.model.Group;
022    import com.liferay.portal.model.Organization;
023    import com.liferay.portal.model.Role;
024    import com.liferay.portal.model.RoleConstants;
025    import com.liferay.portal.model.Team;
026    import com.liferay.portal.model.User;
027    import com.liferay.portal.model.UserGroup;
028    import com.liferay.portal.security.permission.ActionKeys;
029    import com.liferay.portal.service.GroupLocalServiceUtil;
030    import com.liferay.portal.service.OrganizationLocalServiceUtil;
031    import com.liferay.portal.service.RoleLocalServiceUtil;
032    import com.liferay.portal.service.TeamLocalServiceUtil;
033    import com.liferay.portal.service.UserGroupLocalServiceUtil;
034    import com.liferay.portal.service.UserLocalServiceUtil;
035    import com.liferay.portal.service.permission.GroupPermissionUtil;
036    import com.liferay.portal.service.permission.OrganizationPermissionUtil;
037    import com.liferay.portal.service.permission.RolePermissionUtil;
038    import com.liferay.portal.service.permission.UserGroupPermissionUtil;
039    import com.liferay.portal.theme.ThemeDisplay;
040    import com.liferay.portal.util.PortalUtil;
041    
042    import java.util.ArrayList;
043    import java.util.LinkedHashMap;
044    import java.util.LinkedHashSet;
045    import java.util.List;
046    import java.util.Set;
047    
048    /**
049     * @author Raymond Aug??
050     */
051    public class AnnouncementsUtil {
052    
053            public static LinkedHashMap<Long, long[]> getAnnouncementScopes(long userId)
054                    throws PortalException {
055    
056                    LinkedHashMap<Long, long[]> scopes = new LinkedHashMap<>();
057    
058                    // General announcements
059    
060                    scopes.put(Long.valueOf(0), new long[] {0});
061    
062                    // Personal announcements
063    
064                    scopes.put(_USER_CLASS_NAME_ID, new long[] {userId});
065    
066                    // Organization announcements
067    
068                    List<Group> groupsList = new ArrayList<>();
069    
070                    List<Organization> organizations =
071                            OrganizationLocalServiceUtil.getUserOrganizations(userId);
072    
073                    if (!organizations.isEmpty()) {
074                            List<Organization> organizationsList = new ArrayList<>();
075    
076                            organizationsList.addAll(organizations);
077    
078                            for (Organization organization : organizations) {
079                                    groupsList.add(organization.getGroup());
080    
081                                    List<Organization> parentOrganizations =
082                                            OrganizationLocalServiceUtil.getParentOrganizations(
083                                                    organization.getOrganizationId());
084    
085                                    for (Organization parentOrganization : parentOrganizations) {
086                                            organizationsList.add(parentOrganization);
087                                            groupsList.add(parentOrganization.getGroup());
088                                    }
089                            }
090    
091                            scopes.put(
092                                    _ORGANIZATION_CLASS_NAME_ID,
093                                    _getOrganizationIds(organizationsList));
094                    }
095    
096                    // Site announcements
097    
098                    List<Group> groups = GroupLocalServiceUtil.getUserGroups(userId, true);
099    
100                    if (!groups.isEmpty()) {
101                            scopes.put(_GROUP_CLASS_NAME_ID, _getGroupIds(groups));
102    
103                            groupsList.addAll(groups);
104                    }
105    
106                    // User group announcements
107    
108                    List<UserGroup> userGroups =
109                            UserGroupLocalServiceUtil.getUserUserGroups(userId);
110    
111                    if (!userGroups.isEmpty()) {
112                            scopes.put(_USER_GROUP_CLASS_NAME_ID, _getUserGroupIds(userGroups));
113    
114                            for (UserGroup userGroup : userGroups) {
115                                    groupsList.add(userGroup.getGroup());
116                            }
117                    }
118    
119                    // Role announcements
120    
121                    Set<Role> roles = new LinkedHashSet<>();
122    
123                    if (!groupsList.isEmpty()) {
124                            roles.addAll(
125                                    RoleLocalServiceUtil.getUserRelatedRoles(userId, groupsList));
126    
127                            for (Group group : groupsList) {
128                                    roles.addAll(
129                                            RoleLocalServiceUtil.getUserGroupRoles(
130                                                    userId, group.getGroupId()));
131                                    roles.addAll(
132                                            RoleLocalServiceUtil.getUserGroupGroupRoles(
133                                                    userId, group.getGroupId()));
134                            }
135                    }
136                    else {
137                            roles.addAll(RoleLocalServiceUtil.getUserRoles(userId));
138                    }
139    
140                    List<Team> teams = TeamLocalServiceUtil.getUserTeams(userId);
141    
142                    for (Team team : teams) {
143                            roles.add(team.getRole());
144                    }
145    
146                    if (_PERMISSIONS_CHECK_GUEST_ENABLED) {
147                            User user = UserLocalServiceUtil.getUserById(userId);
148    
149                            Role guestRole = RoleLocalServiceUtil.getRole(
150                                    user.getCompanyId(), RoleConstants.GUEST);
151    
152                            roles.add(guestRole);
153                    }
154    
155                    if (!roles.isEmpty()) {
156                            scopes.put(_ROLE_CLASS_NAME_ID, _getRoleIds(roles));
157                    }
158    
159                    return scopes;
160            }
161    
162            public static List<Group> getGroups(ThemeDisplay themeDisplay)
163                    throws Exception {
164    
165                    List<Group> filteredGroups = new ArrayList<>();
166    
167                    List<Group> groups = GroupLocalServiceUtil.getUserGroups(
168                            themeDisplay.getUserId(), true);
169    
170                    for (Group group : groups) {
171                            if (((group.isOrganization() && group.isSite()) ||
172                                     group.isRegularSite()) &&
173                                    GroupPermissionUtil.contains(
174                                            themeDisplay.getPermissionChecker(), group.getGroupId(),
175                                            ActionKeys.MANAGE_ANNOUNCEMENTS)) {
176    
177                                    filteredGroups.add(group);
178                            }
179                    }
180    
181                    return filteredGroups;
182            }
183    
184            public static List<Organization> getOrganizations(ThemeDisplay themeDisplay)
185                    throws Exception {
186    
187                    List<Organization> filteredOrganizations = new ArrayList<>();
188    
189                    List<Organization> organizations =
190                            OrganizationLocalServiceUtil.getUserOrganizations(
191                                    themeDisplay.getUserId());
192    
193                    for (Organization organization : organizations) {
194                            if (OrganizationPermissionUtil.contains(
195                                            themeDisplay.getPermissionChecker(),
196                                            organization.getOrganizationId(),
197                                            ActionKeys.MANAGE_ANNOUNCEMENTS)) {
198    
199                                    filteredOrganizations.add(organization);
200                            }
201                    }
202    
203                    return filteredOrganizations;
204            }
205    
206            public static List<Role> getRoles(ThemeDisplay themeDisplay)
207                    throws Exception {
208    
209                    List<Role> filteredRoles = new ArrayList<>();
210    
211                    List<Role> roles = RoleLocalServiceUtil.getRoles(
212                            themeDisplay.getCompanyId());
213    
214                    for (Role role : roles) {
215                            if (role.isTeam()) {
216                                    Team team = TeamLocalServiceUtil.getTeam(role.getClassPK());
217    
218                                    if (GroupPermissionUtil.contains(
219                                                    themeDisplay.getPermissionChecker(), team.getGroupId(),
220                                                    ActionKeys.MANAGE_ANNOUNCEMENTS) ||
221                                            RolePermissionUtil.contains(
222                                                    themeDisplay.getPermissionChecker(),
223                                                    themeDisplay.getScopeGroupId(), role.getRoleId(),
224                                                    ActionKeys.MANAGE_ANNOUNCEMENTS)) {
225    
226                                            filteredRoles.add(role);
227                                    }
228                            }
229                            else if (RolePermissionUtil.contains(
230                                                    themeDisplay.getPermissionChecker(), role.getRoleId(),
231                                                    ActionKeys.MANAGE_ANNOUNCEMENTS)) {
232    
233                                    filteredRoles.add(role);
234                            }
235                    }
236    
237                    return filteredRoles;
238            }
239    
240            public static List<UserGroup> getUserGroups(ThemeDisplay themeDisplay)
241                    throws Exception {
242    
243                    List<UserGroup> filteredUserGroups = new ArrayList<>();
244    
245                    List<UserGroup> userGroups = UserGroupLocalServiceUtil.getUserGroups(
246                            themeDisplay.getCompanyId());
247    
248                    for (UserGroup userGroup : userGroups) {
249                            if (UserGroupPermissionUtil.contains(
250                                            themeDisplay.getPermissionChecker(),
251                                            userGroup.getUserGroupId(),
252                                            ActionKeys.MANAGE_ANNOUNCEMENTS)) {
253    
254                                    filteredUserGroups.add(userGroup);
255                            }
256                    }
257    
258                    return filteredUserGroups;
259            }
260    
261            private static long[] _getGroupIds(List<Group> groups) {
262                    long[] groupIds = new long[groups.size()];
263    
264                    int i = 0;
265    
266                    for (Group group : groups) {
267                            groupIds[i++] = group.getGroupId();
268                    }
269    
270                    return groupIds;
271            }
272    
273            private static long[] _getOrganizationIds(
274                    List<Organization> organizations) {
275    
276                    long[] organizationIds = new long[organizations.size()];
277    
278                    int i = 0;
279    
280                    for (Organization organization : organizations) {
281                            organizationIds[i++] = organization.getOrganizationId();
282                    }
283    
284                    return organizationIds;
285            }
286    
287            private static long[] _getRoleIds(Set<Role> roles) {
288                    long[] roleIds = new long[roles.size()];
289    
290                    int i = 0;
291    
292                    for (Role role : roles) {
293                            roleIds[i++] = role.getRoleId();
294                    }
295    
296                    return roleIds;
297            }
298    
299            private static long[] _getUserGroupIds(List<UserGroup> userGroups) {
300                    long[] userGroupIds = new long[userGroups.size()];
301    
302                    int i = 0;
303    
304                    for (UserGroup userGroup : userGroups) {
305                            userGroupIds[i++] = userGroup.getUserGroupId();
306                    }
307    
308                    return userGroupIds;
309            }
310    
311            private static final long _GROUP_CLASS_NAME_ID = PortalUtil.getClassNameId(
312                    Group.class.getName());
313    
314            private static final long _ORGANIZATION_CLASS_NAME_ID =
315                    PortalUtil.getClassNameId(Organization.class.getName());
316    
317            private static final boolean _PERMISSIONS_CHECK_GUEST_ENABLED =
318                    GetterUtil.getBoolean(
319                            PropsUtil.get(PropsKeys.PERMISSIONS_CHECK_GUEST_ENABLED));
320    
321            private static final long _ROLE_CLASS_NAME_ID = PortalUtil.getClassNameId(
322                    Role.class.getName());
323    
324            private static final long _USER_CLASS_NAME_ID = PortalUtil.getClassNameId(
325                    User.class.getName());
326    
327            private static final long _USER_GROUP_CLASS_NAME_ID =
328                    PortalUtil.getClassNameId(UserGroup.class.getName());
329    
330    }