001    /**
002     * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved.
003     *
004     * The contents of this file are subject to the terms of the Liferay Enterprise
005     * Subscription License ("License"). You may not use this file except in
006     * compliance with the License. You can obtain a copy of the License by
007     * contacting Liferay, Inc. See the License for the specific language governing
008     * permissions and limitations under the License, including but not limited to
009     * distribution rights of the Software.
010     *
011     *
012     *
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> getUserGroupRoles(
222                            long userId, long groupId, int start, int end)
223                    throws SystemException {
224    
225                    return userGroupRolePersistence.findByU_G(userId, groupId, start, end);
226            }
227    
228            @Override
229            public List<UserGroupRole> getUserGroupRolesByGroup(long groupId)
230                    throws SystemException {
231    
232                    return userGroupRolePersistence.findByGroupId(groupId);
233            }
234    
235            @Override
236            public List<UserGroupRole> getUserGroupRolesByGroupAndRole(
237                            long groupId, long roleId)
238                    throws SystemException {
239    
240                    return userGroupRolePersistence.findByG_R(groupId, roleId);
241            }
242    
243            @Override
244            public List<UserGroupRole> getUserGroupRolesByUserUserGroupAndGroup(
245                            long userId, long groupId)
246                    throws SystemException {
247    
248                    return userGroupRoleFinder.findByUserUserGroupGroupRole(
249                            userId, groupId);
250            }
251    
252            @Override
253            public int getUserGroupRolesCount(long userId, long groupId)
254                    throws SystemException {
255    
256                    return userGroupRolePersistence.countByU_G(userId, groupId);
257            }
258    
259            @Override
260            public boolean hasUserGroupRole(long userId, long groupId, long roleId)
261                    throws SystemException {
262    
263                    return hasUserGroupRole(userId, groupId, roleId, false);
264            }
265    
266            @Override
267            public boolean hasUserGroupRole(
268                            long userId, long groupId, long roleId, boolean inherit)
269                    throws SystemException {
270    
271                    UserGroupRolePK userGroupRolePK = new UserGroupRolePK(
272                            userId, groupId, roleId);
273    
274                    UserGroupRole userGroupRole =
275                            userGroupRolePersistence.fetchByPrimaryKey(userGroupRolePK);
276    
277                    if (userGroupRole != null) {
278                            return true;
279                    }
280    
281                    if (inherit) {
282                            if (roleFinder.countByU_G_R(userId, groupId, roleId) > 0) {
283                                    return true;
284                            }
285                    }
286    
287                    return false;
288            }
289    
290            @Override
291            public boolean hasUserGroupRole(long userId, long groupId, String roleName)
292                    throws PortalException, SystemException {
293    
294                    return hasUserGroupRole(userId, groupId, roleName, false);
295            }
296    
297            @Override
298            public boolean hasUserGroupRole(
299                            long userId, long groupId, String roleName, boolean inherit)
300                    throws PortalException, SystemException {
301    
302                    User user = userPersistence.findByPrimaryKey(userId);
303    
304                    long companyId = user.getCompanyId();
305    
306                    Role role = rolePersistence.fetchByC_N(companyId, roleName);
307    
308                    if (role == null) {
309                            return false;
310                    }
311    
312                    return hasUserGroupRole(userId, groupId, role.getRoleId(), inherit);
313            }
314    
315            protected UserGroupRole addUserGroupRole(
316                            long userId, long groupId, long roleId)
317                    throws SystemException {
318    
319                    UserGroupRolePK userGroupRolePK = new UserGroupRolePK(
320                            userId, groupId, roleId);
321    
322                    UserGroupRole userGroupRole =
323                            userGroupRolePersistence.fetchByPrimaryKey(userGroupRolePK);
324    
325                    if (userGroupRole == null) {
326                            userGroupRole = userGroupRolePersistence.create(userGroupRolePK);
327    
328                            userGroupRolePersistence.update(userGroupRole);
329                    }
330    
331                    return userGroupRole;
332            }
333    
334    }