1   /**
2    * Copyright (c) 2000-2009 Liferay, Inc. All rights reserved.
3    *
4    * Permission is hereby granted, free of charge, to any person obtaining a copy
5    * of this software and associated documentation files (the "Software"), to deal
6    * in the Software without restriction, including without limitation the rights
7    * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8    * copies of the Software, and to permit persons to whom the Software is
9    * furnished to do so, subject to the following conditions:
10   *
11   * The above copyright notice and this permission notice shall be included in
12   * all copies or substantial portions of the Software.
13   *
14   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20   * SOFTWARE.
21   */
22  
23  package com.liferay.portal.service.impl;
24  
25  import com.liferay.portal.NoSuchResourcePermissionException;
26  import com.liferay.portal.PortalException;
27  import com.liferay.portal.SystemException;
28  import com.liferay.portal.model.ResourceAction;
29  import com.liferay.portal.model.ResourceConstants;
30  import com.liferay.portal.model.ResourcePermission;
31  import com.liferay.portal.model.ResourcePermissionConstants;
32  import com.liferay.portal.security.permission.PermissionCacheUtil;
33  import com.liferay.portal.service.base.ResourcePermissionLocalServiceBaseImpl;
34  
35  import java.util.ArrayList;
36  import java.util.Collections;
37  import java.util.List;
38  
39  /**
40   * <a href="ResourcePermissionLocalServiceImpl.java.html"><b><i>View Source</i>
41   * </b></a>
42   *
43   * @author Brian Wing Shun Chan
44   *
45   */
46  public class ResourcePermissionLocalServiceImpl
47      extends ResourcePermissionLocalServiceBaseImpl {
48  
49      public void addResourcePermission(
50              long companyId, String name, int scope, String primKey, long roleId,
51              String actionId)
52          throws PortalException, SystemException {
53  
54          if (scope == ResourceConstants.SCOPE_COMPANY) {
55  
56              // Remove group permission
57  
58              removeResourcePermissions(
59                  companyId, name, ResourceConstants.SCOPE_GROUP, roleId,
60                  actionId);
61          }
62          else if (scope == ResourceConstants.SCOPE_GROUP) {
63  
64              // Remove company permission
65  
66              removeResourcePermissions(
67                  companyId, name, ResourceConstants.SCOPE_COMPANY, roleId,
68                  actionId);
69          }
70          else if (scope == ResourceConstants.SCOPE_INDIVIDUAL) {
71              throw new NoSuchResourcePermissionException();
72          }
73  
74          updateResourcePermission(
75              companyId, name, scope, primKey, roleId, new String[] {actionId},
76              ResourcePermissionConstants.OPERATOR_ADD);
77  
78          PermissionCacheUtil.clearCache();
79      }
80  
81      public List<String> getAvailableResourcePermissionActionIds(
82              long companyId, String name, int scope, String primKey, long roleId,
83              List<String> actionIds)
84          throws PortalException, SystemException {
85  
86          ResourcePermission resourcePermission =
87              resourcePermissionPersistence.fetchByC_N_S_P_R(
88                  companyId, name, scope, primKey, roleId);
89  
90          if (resourcePermission == null) {
91              return Collections.EMPTY_LIST;
92          }
93  
94          List<String> availableActionIds = new ArrayList<String>(
95              actionIds.size());
96  
97          for (String actionId : actionIds) {
98              ResourceAction resourceAction =
99                  resourceActionLocalService.getResourceAction(name, actionId);
100 
101             if (hasActionId(resourcePermission, resourceAction)) {
102                 availableActionIds.add(actionId);
103             }
104         }
105 
106         return availableActionIds;
107     }
108 
109     public int getResourcePermissionsCount(
110             long companyId, String name, int scope, String primKey)
111         throws SystemException {
112 
113         return resourcePermissionPersistence.countByC_N_S_P(
114             companyId, name, scope, primKey);
115     }
116 
117     public List<ResourcePermission> getRoleResourcePermissions(long roleId)
118         throws SystemException {
119 
120         return resourcePermissionPersistence.findByRoleId(roleId);
121     }
122 
123     public boolean hasActionId(
124         ResourcePermission resourcePermission, ResourceAction resourceAction) {
125 
126         long actionIds = resourcePermission.getActionIds();
127         long bitwiseValue = resourceAction.getBitwiseValue();
128 
129         if ((actionIds & bitwiseValue) == bitwiseValue) {
130             return true;
131         }
132         else {
133             return false;
134         }
135     }
136 
137     public boolean hasResourcePermission(
138             long companyId, String name, int scope, String primKey, long roleId,
139             String actionId)
140         throws PortalException, SystemException {
141 
142         ResourcePermission resourcePermission =
143             resourcePermissionPersistence.fetchByC_N_S_P_R(
144                 companyId, name, scope, primKey, roleId);
145 
146         if (resourcePermission == null) {
147             return false;
148         }
149 
150         ResourceAction resourceAction =
151             resourceActionLocalService.getResourceAction(name, actionId);
152 
153         if (hasActionId(resourcePermission, resourceAction)) {
154             return true;
155         }
156         else {
157             return false;
158         }
159     }
160 
161     public boolean hasScopeResourcePermission(
162             long companyId, String name, int scope, long roleId,
163             String actionId)
164         throws PortalException, SystemException {
165 
166         List<ResourcePermission> resourcePermissions =
167             resourcePermissionPersistence.findByC_N_S(companyId, name, scope);
168 
169         for (ResourcePermission resourcePermission : resourcePermissions) {
170             if (hasResourcePermission(
171                     companyId, name, scope, resourcePermission.getPrimKey(),
172                     roleId, actionId)) {
173 
174                 return true;
175             }
176         }
177 
178         return false;
179     }
180 
181     public void removeResourcePermission(
182             long companyId, String name, int scope, String primKey, long roleId,
183             String actionId)
184         throws PortalException, SystemException {
185 
186         updateResourcePermission(
187             companyId, name, scope, primKey, roleId, new String[] {actionId},
188             ResourcePermissionConstants.OPERATOR_REMOVE);
189 
190         PermissionCacheUtil.clearCache();
191     }
192 
193     public void removeResourcePermissions(
194             long companyId, String name, int scope, long roleId,
195             String actionId)
196         throws PortalException, SystemException {
197 
198         List<ResourcePermission> resourcePermissions =
199             resourcePermissionPersistence.findByC_N_S(companyId, name, scope);
200 
201         for (ResourcePermission resourcePermission : resourcePermissions) {
202             updateResourcePermission(
203                 companyId, name, scope, resourcePermission.getPrimKey(), roleId,
204                 new String[] {actionId},
205                 ResourcePermissionConstants.OPERATOR_REMOVE);
206         }
207 
208         PermissionCacheUtil.clearCache();
209     }
210 
211     public void setResourcePermissions(
212             long companyId, String name, int scope, String primKey, long roleId,
213             String[] actionIds)
214         throws PortalException, SystemException {
215 
216         updateResourcePermission(
217             companyId, name, scope, primKey, roleId, actionIds,
218             ResourcePermissionConstants.OPERATOR_SET);
219     }
220 
221     protected void updateResourcePermission(
222             long companyId, String name, int scope, String primKey, long roleId,
223             String[] actionIds, int operator)
224         throws PortalException, SystemException {
225 
226         ResourcePermission resourcePermission =
227             resourcePermissionPersistence.fetchByC_N_S_P_R(
228                 companyId, name, scope, primKey, roleId);
229 
230         if (resourcePermission == null) {
231             if (operator == ResourcePermissionConstants.OPERATOR_REMOVE) {
232                 return;
233             }
234 
235             long resourcePermissionId = counterLocalService.increment(
236                 ResourcePermission.class.getName());
237 
238             resourcePermission = resourcePermissionPersistence.create(
239                 resourcePermissionId);
240 
241             resourcePermission.setCompanyId(companyId);
242             resourcePermission.setName(name);
243             resourcePermission.setScope(scope);
244             resourcePermission.setPrimKey(primKey);
245             resourcePermission.setRoleId(roleId);
246         }
247 
248         long actionIdsLong = resourcePermission.getActionIds();
249 
250         if (operator == ResourcePermissionConstants.OPERATOR_SET) {
251             actionIdsLong = 0;
252         }
253 
254         for (String actionId : actionIds) {
255             ResourceAction resourceAction =
256                 resourceActionLocalService.getResourceAction(name, actionId);
257 
258             if ((operator == ResourcePermissionConstants.OPERATOR_ADD) ||
259                 (operator == ResourcePermissionConstants.OPERATOR_SET)) {
260 
261                 actionIdsLong |= resourceAction.getBitwiseValue();
262             }
263             else {
264                 actionIdsLong =
265                     actionIdsLong & (~resourceAction.getBitwiseValue());
266             }
267         }
268 
269         resourcePermission.setActionIds(actionIdsLong);
270 
271         resourcePermissionPersistence.update(resourcePermission, false);
272 
273         PermissionCacheUtil.clearCache();
274     }
275 
276 }