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