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.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<UserGroupRole>();
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();
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<UserGroupRole>();
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();
081    
082                    return userGroupRoles;
083            }
084    
085            @Override
086            public UserGroupRole deleteUserGroupRole(UserGroupRole userGroupRole) {
087                    userGroupRolePersistence.remove(userGroupRole);
088    
089                    PermissionCacheUtil.clearCache();
090    
091                    return userGroupRole;
092            }
093    
094            @Override
095            public void deleteUserGroupRoles(
096                    long userId, long groupId, long[] roleIds) {
097    
098                    for (long roleId : roleIds) {
099                            UserGroupRolePK userGroupRolePK = new UserGroupRolePK(
100                                    userId, groupId, roleId);
101    
102                            try {
103                                    userGroupRolePersistence.remove(userGroupRolePK);
104                            }
105                            catch (NoSuchUserGroupRoleException nsugre) {
106                            }
107                    }
108    
109                    PermissionCacheUtil.clearCache();
110            }
111    
112            @Override
113            public void deleteUserGroupRoles(long userId, long[] groupIds) {
114                    for (long groupId : groupIds) {
115                            userGroupRolePersistence.removeByU_G(userId, groupId);
116                    }
117    
118                    PermissionCacheUtil.clearCache();
119            }
120    
121            @Override
122            public void deleteUserGroupRoles(long[] userIds, long groupId) {
123                    for (long userId : userIds) {
124                            userGroupRolePersistence.removeByU_G(userId, groupId);
125                    }
126    
127                    PermissionCacheUtil.clearCache();
128            }
129    
130            @Override
131            public void deleteUserGroupRoles(
132                    long[] userIds, long groupId, int roleType) {
133    
134                    List<Role> roles = rolePersistence.findByT_S(
135                            roleType, StringPool.BLANK);
136    
137                    for (long userId : userIds) {
138                            for (Role role : roles) {
139                                    UserGroupRolePK userGroupRolePK = new UserGroupRolePK(
140                                            userId, groupId, role.getRoleId());
141    
142                                    try {
143                                            userGroupRolePersistence.remove(userGroupRolePK);
144                                    }
145                                    catch (NoSuchUserGroupRoleException nsugre) {
146                                    }
147                            }
148                    }
149    
150                    PermissionCacheUtil.clearCache();
151            }
152    
153            @Override
154            public void deleteUserGroupRoles(
155                    long[] userIds, long groupId, long roleId) {
156    
157                    for (long userId : userIds) {
158                            UserGroupRolePK pk = new UserGroupRolePK(userId, groupId, roleId);
159    
160                            try {
161                                    userGroupRolePersistence.remove(pk);
162                            }
163                            catch (NoSuchUserGroupRoleException nsugre) {
164                            }
165                    }
166    
167                    PermissionCacheUtil.clearCache();
168            }
169    
170            @Override
171            public void deleteUserGroupRolesByGroupId(long groupId) {
172                    userGroupRolePersistence.removeByGroupId(groupId);
173    
174                    PermissionCacheUtil.clearCache();
175            }
176    
177            @Override
178            public void deleteUserGroupRolesByRoleId(long roleId) {
179                    userGroupRolePersistence.removeByRoleId(roleId);
180    
181                    PermissionCacheUtil.clearCache();
182            }
183    
184            @Override
185            public void deleteUserGroupRolesByUserId(long userId) {
186                    userGroupRolePersistence.removeByUserId(userId);
187    
188                    PermissionCacheUtil.clearCache();
189            }
190    
191            @Override
192            public List<UserGroupRole> getUserGroupRoles(long userId) {
193                    return userGroupRolePersistence.findByUserId(userId);
194            }
195    
196            @Override
197            public List<UserGroupRole> getUserGroupRoles(long userId, long groupId) {
198                    return userGroupRolePersistence.findByU_G(userId, groupId);
199            }
200    
201            @Override
202            public List<UserGroupRole> getUserGroupRoles(
203                    long userId, long groupId, int start, int end) {
204    
205                    return userGroupRolePersistence.findByU_G(userId, groupId, start, end);
206            }
207    
208            @Override
209            public List<UserGroupRole> getUserGroupRolesByGroup(long groupId) {
210                    return userGroupRolePersistence.findByGroupId(groupId);
211            }
212    
213            @Override
214            public List<UserGroupRole> getUserGroupRolesByGroupAndRole(
215                    long groupId, long roleId) {
216    
217                    return userGroupRolePersistence.findByG_R(groupId, roleId);
218            }
219    
220            @Override
221            public List<UserGroupRole> getUserGroupRolesByUserUserGroupAndGroup(
222                    long userId, long groupId) {
223    
224                    return userGroupRoleFinder.findByUserUserGroupGroupRole(
225                            userId, groupId);
226            }
227    
228            @Override
229            public int getUserGroupRolesCount(long userId, long groupId) {
230                    return userGroupRolePersistence.countByU_G(userId, groupId);
231            }
232    
233            @Override
234            public boolean hasUserGroupRole(long userId, long groupId, long roleId) {
235                    return hasUserGroupRole(userId, groupId, roleId, false);
236            }
237    
238            @Override
239            public boolean hasUserGroupRole(
240                    long userId, long groupId, long roleId, boolean inherit) {
241    
242                    UserGroupRolePK userGroupRolePK = new UserGroupRolePK(
243                            userId, groupId, roleId);
244    
245                    UserGroupRole userGroupRole =
246                            userGroupRolePersistence.fetchByPrimaryKey(userGroupRolePK);
247    
248                    if (userGroupRole != null) {
249                            return true;
250                    }
251    
252                    if (inherit) {
253                            if (roleFinder.countByU_G_R(userId, groupId, roleId) > 0) {
254                                    return true;
255                            }
256                    }
257    
258                    return false;
259            }
260    
261            @Override
262            public boolean hasUserGroupRole(long userId, long groupId, String roleName)
263                    throws PortalException {
264    
265                    return hasUserGroupRole(userId, groupId, roleName, false);
266            }
267    
268            @Override
269            public boolean hasUserGroupRole(
270                            long userId, long groupId, String roleName, boolean inherit)
271                    throws PortalException {
272    
273                    User user = userPersistence.findByPrimaryKey(userId);
274    
275                    long companyId = user.getCompanyId();
276    
277                    Role role = rolePersistence.fetchByC_N(companyId, roleName);
278    
279                    if (role == null) {
280                            return false;
281                    }
282    
283                    return hasUserGroupRole(userId, groupId, role.getRoleId(), inherit);
284            }
285    
286            protected UserGroupRole addUserGroupRole(
287                    long userId, long groupId, long roleId) {
288    
289                    UserGroupRolePK userGroupRolePK = new UserGroupRolePK(
290                            userId, groupId, roleId);
291    
292                    UserGroupRole userGroupRole =
293                            userGroupRolePersistence.fetchByPrimaryKey(userGroupRolePK);
294    
295                    if (userGroupRole == null) {
296                            userGroupRole = userGroupRolePersistence.create(userGroupRolePK);
297    
298                            userGroupRolePersistence.update(userGroupRole);
299                    }
300    
301                    return userGroupRole;
302            }
303    
304    }