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