001    /**
002     * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved.
003     *
004     * The contents of this file are subject to the terms of the Liferay Enterprise
005     * Subscription License ("License"). You may not use this file except in
006     * compliance with the License. You can obtain a copy of the License by
007     * contacting Liferay, Inc. See the License for the specific language governing
008     * permissions and limitations under the License, including but not limited to
009     * distribution rights of the Software.
010     *
011     *
012     *
013     */
014    
015    package com.liferay.portlet.announcements.util;
016    
017    import com.liferay.portal.kernel.exception.PortalException;
018    import com.liferay.portal.kernel.exception.SystemException;
019    import com.liferay.portal.kernel.util.ArrayUtil;
020    import com.liferay.portal.kernel.util.GetterUtil;
021    import com.liferay.portal.kernel.util.ListUtil;
022    import com.liferay.portal.kernel.util.PropsKeys;
023    import com.liferay.portal.kernel.util.PropsUtil;
024    import com.liferay.portal.model.Group;
025    import com.liferay.portal.model.Organization;
026    import com.liferay.portal.model.Role;
027    import com.liferay.portal.model.RoleConstants;
028    import com.liferay.portal.model.Team;
029    import com.liferay.portal.model.User;
030    import com.liferay.portal.model.UserGroup;
031    import com.liferay.portal.model.UserGroupGroupRole;
032    import com.liferay.portal.model.UserGroupRole;
033    import com.liferay.portal.security.permission.ActionKeys;
034    import com.liferay.portal.service.GroupLocalServiceUtil;
035    import com.liferay.portal.service.OrganizationLocalServiceUtil;
036    import com.liferay.portal.service.RoleLocalServiceUtil;
037    import com.liferay.portal.service.TeamLocalServiceUtil;
038    import com.liferay.portal.service.UserGroupGroupRoleLocalServiceUtil;
039    import com.liferay.portal.service.UserGroupLocalServiceUtil;
040    import com.liferay.portal.service.UserGroupRoleLocalServiceUtil;
041    import com.liferay.portal.service.UserLocalServiceUtil;
042    import com.liferay.portal.service.permission.GroupPermissionUtil;
043    import com.liferay.portal.service.permission.OrganizationPermissionUtil;
044    import com.liferay.portal.service.permission.RolePermissionUtil;
045    import com.liferay.portal.service.permission.UserGroupPermissionUtil;
046    import com.liferay.portal.theme.ThemeDisplay;
047    import com.liferay.portal.util.PortalUtil;
048    
049    import java.util.ArrayList;
050    import java.util.HashSet;
051    import java.util.LinkedHashMap;
052    import java.util.List;
053    import java.util.Set;
054    
055    /**
056     * @author Raymond Aug??
057     */
058    public class AnnouncementsUtil {
059    
060            /**
061             * @deprecated As of 6.2.0, replaced by {@link #getAnnouncementScopes(User)}
062             */
063            @Deprecated
064            public static LinkedHashMap<Long, long[]> getAnnouncementScopes(long userId)
065                    throws PortalException, SystemException {
066    
067                    return getAnnouncementScopes(UserLocalServiceUtil.getUserById(userId));
068            }
069    
070            public static LinkedHashMap<Long, long[]> getAnnouncementScopes(User user)
071                    throws PortalException, SystemException {
072    
073                    long userId = user.getUserId();
074    
075                    LinkedHashMap<Long, long[]> scopes = new LinkedHashMap<Long, long[]>();
076    
077                    // General announcements
078    
079                    scopes.put(new Long(0), new long[] {0});
080    
081                    // Personal announcements
082    
083                    scopes.put(_USER_CLASS_NAME_ID, new long[] {userId});
084    
085                    // Organization announcements
086    
087                    List<Group> groupsList = new ArrayList<Group>();
088    
089                    List<Organization> organizations =
090                            OrganizationLocalServiceUtil.getUserOrganizations(userId);
091    
092                    if (!organizations.isEmpty()) {
093                            List<Organization> organizationsList =
094                                    new ArrayList<Organization>();
095    
096                            organizationsList.addAll(organizations);
097    
098                            for (Organization organization : organizations) {
099                                    groupsList.add(organization.getGroup());
100    
101                                    List<Organization> parentOrganizations =
102                                            OrganizationLocalServiceUtil.getParentOrganizations(
103                                                    organization.getOrganizationId());
104    
105                                    for (Organization parentOrganization : parentOrganizations) {
106                                            organizationsList.add(parentOrganization);
107                                            groupsList.add(parentOrganization.getGroup());
108                                    }
109                            }
110    
111                            scopes.put(
112                                    _ORGANIZATION_CLASS_NAME_ID,
113                                    _getOrganizationIds(organizationsList));
114                    }
115    
116                    // Site announcements
117    
118                    List<Group> groups = GroupLocalServiceUtil.getUserGroups(userId, true);
119    
120                    if (!groups.isEmpty()) {
121                            scopes.put(_GROUP_CLASS_NAME_ID, _getGroupIds(groups));
122    
123                            groupsList.addAll(groups);
124                    }
125    
126                    // User group announcements
127    
128                    List<UserGroup> userGroups =
129                            UserGroupLocalServiceUtil.getUserUserGroups(userId);
130    
131                    if (!userGroups.isEmpty()) {
132                            scopes.put(_USER_GROUP_CLASS_NAME_ID, _getUserGroupIds(userGroups));
133    
134                            for (UserGroup userGroup : userGroups) {
135                                    groupsList.add(userGroup.getGroup());
136                            }
137                    }
138    
139                    // Role announcements
140    
141                    Set<Long> roleIds = new HashSet<Long>();
142    
143                    if (!groupsList.isEmpty()) {
144                            List<Role> roles = RoleLocalServiceUtil.getUserRelatedRoles(
145                                    userId, groupsList);
146    
147                            for (Role role : roles) {
148                                    roleIds.add(role.getRoleId());
149                            }
150                    }
151                    else {
152                            List<Role> roles = RoleLocalServiceUtil.getUserRoles(userId);
153    
154                            for (Role role : roles) {
155                                    roleIds.add(role.getRoleId());
156                            }
157                    }
158    
159                    if (!groups.isEmpty() || !organizations.isEmpty()) {
160                            List<UserGroupRole> userGroupRoles =
161                                    UserGroupRoleLocalServiceUtil.getUserGroupRoles(userId);
162    
163                            for (UserGroupRole userGroupRole : userGroupRoles) {
164                                    roleIds.add(userGroupRole.getRoleId());
165                            }
166                    }
167    
168                    if (!userGroups.isEmpty()) {
169                            List<UserGroupGroupRole> userGroupGroupRoles =
170                                    UserGroupGroupRoleLocalServiceUtil.getUserGroupGroupRolesByUser(
171                                            userId);
172    
173                            for (UserGroupGroupRole userGroupGroupRole : userGroupGroupRoles) {
174                                    roleIds.add(userGroupGroupRole.getRoleId());
175                            }
176                    }
177    
178                    List<Team> teams = TeamLocalServiceUtil.getUserTeams(userId);
179    
180                    long[] teamIds = ListUtil.toLongArray(teams, Team.TEAM_ID_ACCESSOR);
181    
182                    long companyId = user.getCompanyId();
183    
184                    if (teamIds.length > 0) {
185                            List<Role> teamRoles = RoleLocalServiceUtil.getTeamsRoles(
186                                    companyId, teamIds);
187    
188                            for (Role teamRole : teamRoles) {
189                                    roleIds.add(teamRole.getRoleId());
190                            }
191                    }
192    
193                    if (_PERMISSIONS_CHECK_GUEST_ENABLED) {
194                            Role guestRole = RoleLocalServiceUtil.getRole(
195                                    companyId, RoleConstants.GUEST);
196    
197                            roleIds.add(guestRole.getRoleId());
198                    }
199    
200                    if (roleIds.size() > 0) {
201                            scopes.put(_ROLE_CLASS_NAME_ID, ArrayUtil.toLongArray(roleIds));
202                    }
203    
204                    return scopes;
205            }
206    
207            public static List<Group> getGroups(ThemeDisplay themeDisplay)
208                    throws Exception {
209    
210                    List<Group> filteredGroups = new ArrayList<Group>();
211    
212                    List<Group> groups = GroupLocalServiceUtil.getUserGroups(
213                            themeDisplay.getUserId(), true);
214    
215                    for (Group group : groups) {
216                            if (((group.isOrganization() && group.isSite()) ||
217                                     group.isRegularSite()) &&
218                                    GroupPermissionUtil.contains(
219                                            themeDisplay.getPermissionChecker(), group.getGroupId(),
220                                            ActionKeys.MANAGE_ANNOUNCEMENTS)) {
221    
222                                    filteredGroups.add(group);
223                            }
224                    }
225    
226                    return filteredGroups;
227            }
228    
229            public static List<Organization> getOrganizations(ThemeDisplay themeDisplay)
230                    throws Exception {
231    
232                    List<Organization> filteredOrganizations =
233                            new ArrayList<Organization>();
234    
235                    List<Organization> organizations =
236                            OrganizationLocalServiceUtil.getUserOrganizations(
237                                    themeDisplay.getUserId());
238    
239                    for (Organization organization : organizations) {
240                            if (OrganizationPermissionUtil.contains(
241                                            themeDisplay.getPermissionChecker(),
242                                            organization.getOrganizationId(),
243                                            ActionKeys.MANAGE_ANNOUNCEMENTS)) {
244    
245                                    filteredOrganizations.add(organization);
246                            }
247                    }
248    
249                    return filteredOrganizations;
250            }
251    
252            public static List<Role> getRoles(ThemeDisplay themeDisplay)
253                    throws Exception {
254    
255                    List<Role> filteredRoles = new ArrayList<Role>();
256    
257                    List<Role> roles = RoleLocalServiceUtil.getRoles(
258                            themeDisplay.getCompanyId());
259    
260                    for (Role role : roles) {
261                            if (role.isTeam()) {
262                                    Team team = TeamLocalServiceUtil.getTeam(role.getClassPK());
263    
264                                    if (GroupPermissionUtil.contains(
265                                                    themeDisplay.getPermissionChecker(), team.getGroupId(),
266                                                    ActionKeys.MANAGE_ANNOUNCEMENTS) ||
267                                            RolePermissionUtil.contains(
268                                                    themeDisplay.getPermissionChecker(),
269                                                    themeDisplay.getScopeGroupId(), role.getRoleId(),
270                                                    ActionKeys.MANAGE_ANNOUNCEMENTS)) {
271    
272                                            filteredRoles.add(role);
273                                    }
274                            }
275                            else if (RolePermissionUtil.contains(
276                                                    themeDisplay.getPermissionChecker(), role.getRoleId(),
277                                                    ActionKeys.MANAGE_ANNOUNCEMENTS)) {
278    
279                                    filteredRoles.add(role);
280                            }
281                    }
282    
283                    return filteredRoles;
284            }
285    
286            public static List<UserGroup> getUserGroups(ThemeDisplay themeDisplay)
287                    throws Exception {
288    
289                    List<UserGroup> filteredUserGroups = new ArrayList<UserGroup>();
290    
291                    List<UserGroup> userGroups = UserGroupLocalServiceUtil.getUserGroups(
292                            themeDisplay.getCompanyId());
293    
294                    for (UserGroup userGroup : userGroups) {
295                            if (UserGroupPermissionUtil.contains(
296                                            themeDisplay.getPermissionChecker(),
297                                            userGroup.getUserGroupId(),
298                                            ActionKeys.MANAGE_ANNOUNCEMENTS)) {
299    
300                                    filteredUserGroups.add(userGroup);
301                            }
302                    }
303    
304                    return filteredUserGroups;
305            }
306    
307            private static long[] _getGroupIds(List<Group> groups) {
308                    long[] groupIds = new long[groups.size()];
309    
310                    int i = 0;
311    
312                    for (Group group : groups) {
313                            groupIds[i++] = group.getGroupId();
314                    }
315    
316                    return groupIds;
317            }
318    
319            private static long[] _getOrganizationIds(
320                    List<Organization> organizations) {
321    
322                    long[] organizationIds = new long[organizations.size()];
323    
324                    int i = 0;
325    
326                    for (Organization organization : organizations) {
327                            organizationIds[i++] = organization.getOrganizationId();
328                    }
329    
330                    return organizationIds;
331            }
332    
333            private static long[] _getUserGroupIds(List<UserGroup> userGroups) {
334                    long[] userGroupIds = new long[userGroups.size()];
335    
336                    int i = 0;
337    
338                    for (UserGroup userGroup : userGroups) {
339                            userGroupIds[i++] = userGroup.getUserGroupId();
340                    }
341    
342                    return userGroupIds;
343            }
344    
345            private static final long _GROUP_CLASS_NAME_ID = PortalUtil.getClassNameId(
346                    Group.class.getName());
347    
348            private static final long _ORGANIZATION_CLASS_NAME_ID =
349                    PortalUtil.getClassNameId(Organization.class.getName());
350    
351            private static final boolean _PERMISSIONS_CHECK_GUEST_ENABLED =
352                    GetterUtil.getBoolean(
353                            PropsUtil.get(PropsKeys.PERMISSIONS_CHECK_GUEST_ENABLED));
354    
355            private static final long _ROLE_CLASS_NAME_ID = PortalUtil.getClassNameId(
356                    Role.class.getName());
357    
358            private static final long _USER_CLASS_NAME_ID = PortalUtil.getClassNameId(
359                    User.class.getName());
360    
361            private static final long _USER_GROUP_CLASS_NAME_ID =
362                    PortalUtil.getClassNameId(UserGroup.class.getName());
363    
364    }