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.portal.service.impl;
016    
017    import com.liferay.portal.exception.NoSuchUserGroupRoleException;
018    import com.liferay.portal.kernel.exception.PortalException;
019    import com.liferay.portal.kernel.util.StringPool;
020    import com.liferay.portal.model.Group;
021    import com.liferay.portal.model.Role;
022    import com.liferay.portal.model.User;
023    import com.liferay.portal.model.UserGroupRole;
024    import com.liferay.portal.security.permission.PermissionCacheUtil;
025    import com.liferay.portal.service.base.UserGroupRoleLocalServiceBaseImpl;
026    import com.liferay.portal.service.persistence.UserGroupRolePK;
027    
028    import java.util.ArrayList;
029    import java.util.List;
030    
031    /**
032     * @author Jorge Ferrer
033     */
034    public class UserGroupRoleLocalServiceImpl
035            extends UserGroupRoleLocalServiceBaseImpl {
036    
037            @Override
038            public List<UserGroupRole> addUserGroupRoles(
039                    long userId, long groupId, long[] roleIds) {
040    
041                    List<UserGroupRole> userGroupRoles = new ArrayList<>();
042    
043                    for (long roleId : roleIds) {
044                            UserGroupRole userGroupRole = addUserGroupRole(
045                                    userId, groupId, roleId);
046    
047                            userGroupRoles.add(userGroupRole);
048                    }
049    
050                    Group group = groupPersistence.fetchByPrimaryKey(groupId);
051    
052                    if (group.isRegularSite()) {
053                            groupPersistence.addUser(groupId, userId);
054                    }
055    
056                    PermissionCacheUtil.clearCache(userId);
057    
058                    return userGroupRoles;
059            }
060    
061            @Override
062            public List<UserGroupRole> addUserGroupRoles(
063                    long[] userIds, long groupId, long roleId) {
064    
065                    List<UserGroupRole> userGroupRoles = new ArrayList<>();
066    
067                    for (long userId : userIds) {
068                            UserGroupRole userGroupRole = addUserGroupRole(
069                                    userId, groupId, roleId);
070    
071                            userGroupRoles.add(userGroupRole);
072                    }
073    
074                    Group group = groupPersistence.fetchByPrimaryKey(groupId);
075    
076                    if (group.isRegularSite()) {
077                            groupPersistence.addUsers(groupId, userIds);
078                    }
079    
080                    PermissionCacheUtil.clearCache(userIds);
081    
082                    return userGroupRoles;
083            }
084    
085            @Override
086            public UserGroupRole deleteUserGroupRole(UserGroupRole userGroupRole) {
087                    userGroupRolePersistence.remove(userGroupRole);
088    
089                    PermissionCacheUtil.clearCache(userGroupRole.getUserId());
090    
091                    return userGroupRole;
092            }
093    
094            @Override
095            public void deleteUserGroupRoles(long groupId, int roleType) {
096                    List<UserGroupRole> userGroupRoles =
097                            userGroupRoleFinder.findByGroupRoleType(groupId, roleType);
098    
099                    for (UserGroupRole userGroupRole : userGroupRoles) {
100                            userGroupRolePersistence.removeByG_R(
101                                    groupId, userGroupRole.getRoleId());
102                    }
103    
104                    PermissionCacheUtil.clearCache();
105            }
106    
107            @Override
108            public void deleteUserGroupRoles(
109                    long userId, long groupId, long[] roleIds) {
110    
111                    for (long roleId : roleIds) {
112                            UserGroupRolePK userGroupRolePK = new UserGroupRolePK(
113                                    userId, groupId, roleId);
114    
115                            try {
116                                    userGroupRolePersistence.remove(userGroupRolePK);
117                            }
118                            catch (NoSuchUserGroupRoleException nsugre) {
119                            }
120                    }
121    
122                    PermissionCacheUtil.clearCache(userId);
123            }
124    
125            @Override
126            public void deleteUserGroupRoles(long userId, long[] groupIds) {
127                    for (long groupId : groupIds) {
128                            userGroupRolePersistence.removeByU_G(userId, groupId);
129                    }
130    
131                    PermissionCacheUtil.clearCache(userId);
132            }
133    
134            @Override
135            public void deleteUserGroupRoles(long[] userIds, long groupId) {
136                    for (long userId : userIds) {
137                            userGroupRolePersistence.removeByU_G(userId, groupId);
138                    }
139    
140                    PermissionCacheUtil.clearCache(userIds);
141            }
142    
143            @Override
144            public void deleteUserGroupRoles(
145                    long[] userIds, long groupId, int roleType) {
146    
147                    List<Role> roles = rolePersistence.findByT_S(
148                            roleType, StringPool.BLANK);
149    
150                    for (long userId : userIds) {
151                            for (Role role : roles) {
152                                    UserGroupRolePK userGroupRolePK = new UserGroupRolePK(
153                                            userId, groupId, role.getRoleId());
154    
155                                    try {
156                                            userGroupRolePersistence.remove(userGroupRolePK);
157                                    }
158                                    catch (NoSuchUserGroupRoleException nsugre) {
159                                    }
160                            }
161                    }
162    
163                    PermissionCacheUtil.clearCache(userIds);
164            }
165    
166            @Override
167            public void deleteUserGroupRoles(
168                    long[] userIds, long groupId, long roleId) {
169    
170                    for (long userId : userIds) {
171                            UserGroupRolePK pk = new UserGroupRolePK(userId, groupId, roleId);
172    
173                            try {
174                                    userGroupRolePersistence.remove(pk);
175                            }
176                            catch (NoSuchUserGroupRoleException nsugre) {
177                            }
178                    }
179    
180                    PermissionCacheUtil.clearCache(userIds);
181            }
182    
183            @Override
184            public void deleteUserGroupRolesByGroupId(long groupId) {
185                    userGroupRolePersistence.removeByGroupId(groupId);
186    
187                    PermissionCacheUtil.clearCache();
188            }
189    
190            @Override
191            public void deleteUserGroupRolesByRoleId(long roleId) {
192                    userGroupRolePersistence.removeByRoleId(roleId);
193    
194                    PermissionCacheUtil.clearCache();
195            }
196    
197            @Override
198            public void deleteUserGroupRolesByUserId(long userId) {
199                    userGroupRolePersistence.removeByUserId(userId);
200    
201                    PermissionCacheUtil.clearCache(userId);
202            }
203    
204            @Override
205            public List<UserGroupRole> getUserGroupRoles(long userId) {
206                    return userGroupRolePersistence.findByUserId(userId);
207            }
208    
209            @Override
210            public List<UserGroupRole> getUserGroupRoles(long userId, long groupId) {
211                    return userGroupRolePersistence.findByU_G(userId, groupId);
212            }
213    
214            @Override
215            public List<UserGroupRole> getUserGroupRoles(
216                    long userId, long groupId, int start, int end) {
217    
218                    return userGroupRolePersistence.findByU_G(userId, groupId, start, end);
219            }
220    
221            @Override
222            public List<UserGroupRole> getUserGroupRolesByGroup(long groupId) {
223                    return userGroupRolePersistence.findByGroupId(groupId);
224            }
225    
226            @Override
227            public List<UserGroupRole> getUserGroupRolesByGroupAndRole(
228                    long groupId, long roleId) {
229    
230                    return userGroupRolePersistence.findByG_R(groupId, roleId);
231            }
232    
233            @Override
234            public List<UserGroupRole> getUserGroupRolesByUserUserGroupAndGroup(
235                    long userId, long groupId) {
236    
237                    return userGroupRoleFinder.findByUserUserGroupGroupRole(
238                            userId, groupId);
239            }
240    
241            @Override
242            public int getUserGroupRolesCount(long userId, long groupId) {
243                    return userGroupRolePersistence.countByU_G(userId, groupId);
244            }
245    
246            @Override
247            public boolean hasUserGroupRole(long userId, long groupId, long roleId) {
248                    return hasUserGroupRole(userId, groupId, roleId, false);
249            }
250    
251            @Override
252            public boolean hasUserGroupRole(
253                    long userId, long groupId, long roleId, boolean inherit) {
254    
255                    UserGroupRolePK userGroupRolePK = new UserGroupRolePK(
256                            userId, groupId, roleId);
257    
258                    UserGroupRole userGroupRole =
259                            userGroupRolePersistence.fetchByPrimaryKey(userGroupRolePK);
260    
261                    if (userGroupRole != null) {
262                            return true;
263                    }
264    
265                    if (inherit) {
266                            if (roleFinder.countByU_G_R(userId, groupId, roleId) > 0) {
267                                    return true;
268                            }
269                    }
270    
271                    return false;
272            }
273    
274            @Override
275            public boolean hasUserGroupRole(long userId, long groupId, String roleName)
276                    throws PortalException {
277    
278                    return hasUserGroupRole(userId, groupId, roleName, false);
279            }
280    
281            @Override
282            public boolean hasUserGroupRole(
283                            long userId, long groupId, String roleName, boolean inherit)
284                    throws PortalException {
285    
286                    User user = userPersistence.findByPrimaryKey(userId);
287    
288                    long companyId = user.getCompanyId();
289    
290                    Role role = rolePersistence.fetchByC_N(companyId, roleName);
291    
292                    if (role == null) {
293                            return false;
294                    }
295    
296                    return hasUserGroupRole(userId, groupId, role.getRoleId(), inherit);
297            }
298    
299            protected UserGroupRole addUserGroupRole(
300                    long userId, long groupId, long roleId) {
301    
302                    UserGroupRolePK userGroupRolePK = new UserGroupRolePK(
303                            userId, groupId, roleId);
304    
305                    UserGroupRole userGroupRole =
306                            userGroupRolePersistence.fetchByPrimaryKey(userGroupRolePK);
307    
308                    if (userGroupRole == null) {
309                            userGroupRole = userGroupRolePersistence.create(userGroupRolePK);
310    
311                            userGroupRolePersistence.update(userGroupRole);
312                    }
313    
314                    return userGroupRole;
315            }
316    
317    }