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> getUserGroupRolesByGroup(long groupId) {
203                    return userGroupRolePersistence.findByGroupId(groupId);
204            }
205    
206            @Override
207            public List<UserGroupRole> getUserGroupRolesByGroupAndRole(
208                    long groupId, long roleId) {
209    
210                    return userGroupRolePersistence.findByG_R(groupId, roleId);
211            }
212    
213            @Override
214            public List<UserGroupRole> getUserGroupRolesByUserUserGroupAndGroup(
215                    long userId, long groupId) {
216    
217                    return userGroupRoleFinder.findByUserUserGroupGroupRole(
218                            userId, groupId);
219            }
220    
221            @Override
222            public boolean hasUserGroupRole(long userId, long groupId, long roleId) {
223                    return hasUserGroupRole(userId, groupId, roleId, false);
224            }
225    
226            @Override
227            public boolean hasUserGroupRole(
228                    long userId, long groupId, long roleId, boolean inherit) {
229    
230                    UserGroupRolePK userGroupRolePK = new UserGroupRolePK(
231                            userId, groupId, roleId);
232    
233                    UserGroupRole userGroupRole =
234                            userGroupRolePersistence.fetchByPrimaryKey(userGroupRolePK);
235    
236                    if (userGroupRole != null) {
237                            return true;
238                    }
239    
240                    if (inherit) {
241                            if (roleFinder.countByU_G_R(userId, groupId, roleId) > 0) {
242                                    return true;
243                            }
244                    }
245    
246                    return false;
247            }
248    
249            @Override
250            public boolean hasUserGroupRole(long userId, long groupId, String roleName)
251                    throws PortalException {
252    
253                    return hasUserGroupRole(userId, groupId, roleName, false);
254            }
255    
256            @Override
257            public boolean hasUserGroupRole(
258                            long userId, long groupId, String roleName, boolean inherit)
259                    throws PortalException {
260    
261                    User user = userPersistence.findByPrimaryKey(userId);
262    
263                    long companyId = user.getCompanyId();
264    
265                    Role role = rolePersistence.fetchByC_N(companyId, roleName);
266    
267                    if (role == null) {
268                            return false;
269                    }
270    
271                    return hasUserGroupRole(userId, groupId, role.getRoleId(), inherit);
272            }
273    
274            protected UserGroupRole addUserGroupRole(
275                    long userId, long groupId, long roleId) {
276    
277                    UserGroupRolePK userGroupRolePK = new UserGroupRolePK(
278                            userId, groupId, roleId);
279    
280                    UserGroupRole userGroupRole =
281                            userGroupRolePersistence.fetchByPrimaryKey(userGroupRolePK);
282    
283                    if (userGroupRole == null) {
284                            userGroupRole = userGroupRolePersistence.create(userGroupRolePK);
285    
286                            userGroupRolePersistence.update(userGroupRole);
287                    }
288    
289                    return userGroupRole;
290            }
291    
292    }