001
014
015 package com.liferay.portal.service.impl;
016
017 import com.liferay.portal.NoSuchResourcePermissionException;
018 import com.liferay.portal.kernel.concurrent.LockRegistry;
019 import com.liferay.portal.kernel.dao.db.DB;
020 import com.liferay.portal.kernel.dao.db.DBFactoryUtil;
021 import com.liferay.portal.kernel.dao.orm.QueryPos;
022 import com.liferay.portal.kernel.dao.orm.SQLQuery;
023 import com.liferay.portal.kernel.dao.orm.Session;
024 import com.liferay.portal.kernel.dao.orm.Type;
025 import com.liferay.portal.kernel.exception.PortalException;
026 import com.liferay.portal.kernel.exception.SystemException;
027 import com.liferay.portal.kernel.search.SearchEngineUtil;
028 import com.liferay.portal.kernel.util.ArrayUtil;
029 import com.liferay.portal.kernel.util.ListUtil;
030 import com.liferay.portal.kernel.util.StringBundler;
031 import com.liferay.portal.kernel.util.StringPool;
032 import com.liferay.portal.kernel.util.StringUtil;
033 import com.liferay.portal.model.Resource;
034 import com.liferay.portal.model.ResourceAction;
035 import com.liferay.portal.model.ResourceConstants;
036 import com.liferay.portal.model.ResourcePermission;
037 import com.liferay.portal.model.ResourcePermissionConstants;
038 import com.liferay.portal.model.Role;
039 import com.liferay.portal.model.RoleConstants;
040 import com.liferay.portal.security.auth.PrincipalException;
041 import com.liferay.portal.security.permission.PermissionCacheUtil;
042 import com.liferay.portal.security.permission.PermissionThreadLocal;
043 import com.liferay.portal.security.permission.ResourceActionsUtil;
044 import com.liferay.portal.service.base.ResourcePermissionLocalServiceBaseImpl;
045 import com.liferay.portal.util.PortalUtil;
046 import com.liferay.portal.util.PropsValues;
047 import com.liferay.portal.util.ResourcePermissionsThreadLocal;
048 import com.liferay.util.dao.orm.CustomSQLUtil;
049
050 import java.util.ArrayList;
051 import java.util.Collection;
052 import java.util.Collections;
053 import java.util.HashMap;
054 import java.util.HashSet;
055 import java.util.List;
056 import java.util.Map;
057 import java.util.Set;
058 import java.util.concurrent.locks.Lock;
059
060
074 public class ResourcePermissionLocalServiceImpl
075 extends ResourcePermissionLocalServiceBaseImpl {
076
077
080 public static final String[] EMPTY_ACTION_IDS = {null};
081
082
121 @Override
122 public void addResourcePermission(
123 long companyId, String name, int scope, String primKey, long roleId,
124 String actionId)
125 throws PortalException, SystemException {
126
127 if (scope == ResourceConstants.SCOPE_COMPANY) {
128
129
130
131 removeResourcePermissions(
132 companyId, name, ResourceConstants.SCOPE_GROUP, roleId,
133 actionId);
134 }
135 else if (scope == ResourceConstants.SCOPE_GROUP) {
136
137
138
139 removeResourcePermissions(
140 companyId, name, ResourceConstants.SCOPE_COMPANY, roleId,
141 actionId);
142 }
143 else if (scope == ResourceConstants.SCOPE_INDIVIDUAL) {
144 throw new NoSuchResourcePermissionException();
145 }
146
147 updateResourcePermission(
148 companyId, name, scope, primKey, roleId, 0, new String[] {actionId},
149 ResourcePermissionConstants.OPERATOR_ADD);
150
151 PermissionCacheUtil.clearCache();
152 }
153
154
172 @Override
173 public void addResourcePermissions(
174 String resourceName, String roleName, int scope,
175 long resourceActionBitwiseValue)
176 throws SystemException {
177
178 List<Role> roles = rolePersistence.findByName(roleName);
179
180 if (roles.isEmpty()) {
181 return;
182 }
183
184 Session session = resourcePermissionPersistence.openSession();
185
186 try {
187
188
189
190 String sql = CustomSQLUtil.get(_UPDATE_ACTION_IDS);
191
192 sql = StringUtil.replace(
193 sql, "[$ROLE_ID$]",
194 ListUtil.toString(roles, Role.ROLE_ID_ACCESSOR));
195
196 SQLQuery sqlQuery = session.createSQLQuery(sql);
197
198 QueryPos qPos = QueryPos.getInstance(sqlQuery);
199
200 qPos.add(resourceActionBitwiseValue);
201 qPos.add(resourceActionBitwiseValue);
202 qPos.add(resourceName);
203 qPos.add(scope);
204
205 sqlQuery.executeUpdate();
206
207
208
209 sql = CustomSQLUtil.get(_FIND_MISSING_RESOURCE_PERMISSIONS);
210
211 sqlQuery = session.createSQLQuery(sql);
212
213 sqlQuery.addScalar("companyId", Type.LONG);
214 sqlQuery.addScalar("name", Type.STRING);
215 sqlQuery.addScalar("scope", Type.INTEGER);
216 sqlQuery.addScalar("primKey", Type.STRING);
217 sqlQuery.addScalar("roleId", Type.LONG);
218
219 qPos = QueryPos.getInstance(sqlQuery);
220
221 qPos.add(resourceName);
222 qPos.add(scope);
223 qPos.add(roleName);
224
225 List<Object[]> resourcePermissionArrays = sqlQuery.list(true);
226
227 if (resourcePermissionArrays.isEmpty()) {
228 return;
229 }
230
231 for (Object[] resourcePermissionArray : resourcePermissionArrays) {
232 long resourcePermissionId = counterLocalService.increment(
233 ResourcePermission.class.getName());
234
235 ResourcePermission resourcePermission =
236 resourcePermissionPersistence.create(resourcePermissionId);
237
238 resourcePermission.setCompanyId(
239 (Long)resourcePermissionArray[0]);
240 resourcePermission.setName((String)resourcePermissionArray[1]);
241 resourcePermission.setScope(
242 (Integer)resourcePermissionArray[2]);
243 resourcePermission.setPrimKey(
244 (String)resourcePermissionArray[3]);
245 resourcePermission.setRoleId((Long)resourcePermissionArray[4]);
246 resourcePermission.setActionIds(resourceActionBitwiseValue);
247
248 session.save(resourcePermission);
249 }
250 }
251 catch (Exception e) {
252 throw new SystemException(e);
253 }
254 finally {
255 resourcePermissionPersistence.closeSession(session);
256
257 resourcePermissionPersistence.clearCache();
258 }
259 }
260
261
284 @Override
285 public void deleteResourcePermissions(
286 long companyId, String name, int scope, long primKey)
287 throws PortalException, SystemException {
288
289 deleteResourcePermissions(
290 companyId, name, scope, String.valueOf(primKey));
291 }
292
293
316 @Override
317 public void deleteResourcePermissions(
318 long companyId, String name, int scope, String primKey)
319 throws PortalException, SystemException {
320
321 List<ResourcePermission> resourcePermissions =
322 resourcePermissionPersistence.findByC_N_S_P(
323 companyId, name, scope, primKey);
324
325 for (ResourcePermission resourcePermission : resourcePermissions) {
326 deleteResourcePermission(
327 resourcePermission.getResourcePermissionId());
328 }
329 }
330
331
348 @Override
349 public List<String> getAvailableResourcePermissionActionIds(
350 long companyId, String name, int scope, String primKey, long roleId,
351 Collection<String> actionIds)
352 throws PortalException, SystemException {
353
354 ResourcePermission resourcePermission =
355 resourcePermissionPersistence.fetchByC_N_S_P_R(
356 companyId, name, scope, primKey, roleId);
357
358 if (resourcePermission == null) {
359 return Collections.emptyList();
360 }
361
362 List<String> availableActionIds = new ArrayList<String>(
363 actionIds.size());
364
365 for (String actionId : actionIds) {
366 ResourceAction resourceAction =
367 resourceActionLocalService.getResourceAction(name, actionId);
368
369 if (hasActionId(resourcePermission, resourceAction)) {
370 availableActionIds.add(actionId);
371 }
372 }
373
374 return availableActionIds;
375 }
376
377 @Override
378 public Map<Long, Set<String>> getAvailableResourcePermissionActionIds(
379 long companyId, String name, int scope, String primKey,
380 long[] roleIds, Collection<String> actionIds)
381 throws PortalException, SystemException {
382
383 List<ResourcePermission> resourcePermissions =
384 resourcePermissionPersistence.findByC_N_S_P_R(
385 companyId, name, scope, primKey, roleIds);
386
387 if (resourcePermissions.isEmpty()) {
388 return Collections.emptyMap();
389 }
390
391 Map<Long, Set<String>> roleIdsToActionIds =
392 new HashMap<Long, Set<String>>();
393
394 for (ResourcePermission resourcePermission : resourcePermissions) {
395 long roleId = resourcePermission.getRoleId();
396
397 Set<String> availableActionIds = roleIdsToActionIds.get(roleId);
398
399 if (availableActionIds != null) {
400 continue;
401 }
402
403 availableActionIds = new HashSet<String>();
404
405 roleIdsToActionIds.put(roleId, availableActionIds);
406
407 for (String actionId : actionIds) {
408 ResourceAction resourceAction =
409 resourceActionLocalService.getResourceAction(
410 name, actionId);
411
412 if (hasActionId(resourcePermission, resourceAction)) {
413 availableActionIds.add(actionId);
414 }
415 }
416 }
417
418 return roleIdsToActionIds;
419 }
420
421
436 @Override
437 public ResourcePermission getResourcePermission(
438 long companyId, String name, int scope, String primKey, long roleId)
439 throws PortalException, SystemException {
440
441 return resourcePermissionPersistence.findByC_N_S_P_R(
442 companyId, name, scope, primKey, roleId);
443 }
444
445
456 @Override
457 public List<ResourcePermission> getResourcePermissions(
458 long companyId, String name, int scope, String primKey)
459 throws SystemException {
460
461 return resourcePermissionPersistence.findByC_N_S_P(
462 companyId, name, scope, primKey);
463 }
464
465
476 @Override
477 public int getResourcePermissionsCount(
478 long companyId, String name, int scope, String primKey)
479 throws SystemException {
480
481 return resourcePermissionPersistence.countByC_N_S_P(
482 companyId, name, scope, primKey);
483 }
484
485
496 @Override
497 public List<ResourcePermission> getResourceResourcePermissions(
498 long companyId, long groupId, String name, String primKey)
499 throws SystemException {
500
501 return resourcePermissionFinder.findByResource(
502 companyId, groupId, name, primKey);
503 }
504
505
512 @Override
513 public List<ResourcePermission> getRoleResourcePermissions(long roleId)
514 throws SystemException {
515
516 return resourcePermissionPersistence.findByRoleId(roleId);
517 }
518
519
540 @Override
541 public List<ResourcePermission> getRoleResourcePermissions(
542 long roleId, int[] scopes, int start, int end)
543 throws SystemException {
544
545 return resourcePermissionFinder.findByR_S(roleId, scopes, start, end);
546 }
547
548
565 @Override
566 public List<ResourcePermission> getScopeResourcePermissions(int[] scopes)
567 throws SystemException {
568
569 return resourcePermissionPersistence.findByScope(scopes);
570 }
571
572
583 @Override
584 public boolean hasActionId(
585 ResourcePermission resourcePermission, ResourceAction resourceAction) {
586
587 long actionIds = resourcePermission.getActionIds();
588 long bitwiseValue = resourceAction.getBitwiseValue();
589
590 if ((actionIds & bitwiseValue) == bitwiseValue) {
591 return true;
592 }
593 else {
594 return false;
595 }
596 }
597
598
619 @Override
620 public boolean hasResourcePermission(
621 List<Resource> resources, long[] roleIds, String actionId)
622 throws PortalException, SystemException {
623
624
625
626
627
628
629
630 for (int i = resources.size() - 1; i >= 0; i--) {
631 Resource resource = resources.get(i);
632
633 if (hasResourcePermission(
634 resource.getCompanyId(), resource.getName(),
635 resource.getScope(), resource.getPrimKey(), roleIds,
636 actionId)) {
637
638 return true;
639 }
640 }
641
642 return false;
643 }
644
645
668 @Override
669 public boolean hasResourcePermission(
670 long companyId, String name, int scope, String primKey, long roleId,
671 String actionId)
672 throws PortalException, SystemException {
673
674 ResourcePermission resourcePermission =
675 resourcePermissionPersistence.fetchByC_N_S_P_R(
676 companyId, name, scope, primKey, roleId);
677
678 if (resourcePermission == null) {
679 return false;
680 }
681
682 ResourceAction resourceAction =
683 resourceActionLocalService.getResourceAction(name, actionId);
684
685 if (hasActionId(resourcePermission, resourceAction)) {
686 return true;
687 }
688
689 return false;
690 }
691
692
716 @Override
717 public boolean hasResourcePermission(
718 long companyId, String name, int scope, String primKey,
719 long[] roleIds, String actionId)
720 throws PortalException, SystemException {
721
722 ResourceAction resourceAction =
723 resourceActionLocalService.getResourceAction(name, actionId);
724
725 DB db = DBFactoryUtil.getDB();
726
727 String dbType = db.getType();
728
729 if ((roleIds.length >
730 PropsValues.
731 PERMISSIONS_ROLE_RESOURCE_PERMISSION_QUERY_THRESHOLD) &&
732 !dbType.equals(DB.TYPE_DERBY) &&
733 !dbType.equals(DB.TYPE_JDATASTORE) &&
734 !dbType.equals(DB.TYPE_SAP)) {
735
736 int count = resourcePermissionFinder.countByC_N_S_P_R_A(
737 companyId, name, scope, primKey, roleIds,
738 resourceAction.getBitwiseValue());
739
740 if (count > 0) {
741 return true;
742 }
743 }
744 else {
745 List<ResourcePermission> resourcePermissions =
746 resourcePermissionPersistence.findByC_N_S_P_R(
747 companyId, name, scope, primKey, roleIds);
748
749 if (resourcePermissions.isEmpty()) {
750 return false;
751 }
752
753 for (ResourcePermission resourcePermission : resourcePermissions) {
754 if (hasActionId(resourcePermission, resourceAction)) {
755 return true;
756 }
757 }
758
759 }
760
761 return false;
762 }
763
764 @Override
765 public boolean[] hasResourcePermissions(
766 long companyId, String name, int scope, String primKey,
767 long[] roleIds, String actionId)
768 throws PortalException, SystemException {
769
770 ResourceAction resourceAction =
771 resourceActionLocalService.getResourceAction(name, actionId);
772
773 List<ResourcePermission> resourcePermissions =
774 resourcePermissionPersistence.findByC_N_S_P_R(
775 companyId, name, scope, primKey, roleIds);
776
777 boolean[] hasResourcePermissions = new boolean[roleIds.length];
778
779 if (resourcePermissions.isEmpty()) {
780 return hasResourcePermissions;
781 }
782
783 for (ResourcePermission resourcePermission : resourcePermissions) {
784 if (hasActionId(resourcePermission, resourceAction)) {
785 long roleId = resourcePermission.getRoleId();
786
787 for (int i = 0; i < roleIds.length; i++) {
788 if (roleIds[i] == roleId) {
789 hasResourcePermissions[i] = true;
790 }
791 }
792 }
793 }
794
795 return hasResourcePermissions;
796 }
797
798
820 @Override
821 public boolean hasScopeResourcePermission(
822 long companyId, String name, int scope, long roleId,
823 String actionId)
824 throws PortalException, SystemException {
825
826 List<ResourcePermission> resourcePermissions =
827 resourcePermissionPersistence.findByC_N_S(companyId, name, scope);
828
829 for (ResourcePermission resourcePermission : resourcePermissions) {
830 if (hasResourcePermission(
831 companyId, name, scope, resourcePermission.getPrimKey(),
832 roleId, actionId)) {
833
834 return true;
835 }
836 }
837
838 return false;
839 }
840
841
850 @Override
851 public void mergePermissions(long fromRoleId, long toRoleId)
852 throws PortalException, SystemException {
853
854 Role fromRole = rolePersistence.findByPrimaryKey(fromRoleId);
855 Role toRole = rolePersistence.findByPrimaryKey(toRoleId);
856
857 if (fromRole.getType() != toRole.getType()) {
858 throw new PortalException("Role types are mismatched");
859 }
860 else if (PortalUtil.isSystemRole(toRole.getName())) {
861 throw new PortalException("Cannot move permissions to system role");
862 }
863 else if (PortalUtil.isSystemRole(fromRole.getName())) {
864 throw new PortalException(
865 "Cannot move permissions from system role");
866 }
867
868 List<ResourcePermission> resourcePermissions =
869 getRoleResourcePermissions(fromRoleId);
870
871 for (ResourcePermission resourcePermission : resourcePermissions) {
872 resourcePermission.setRoleId(toRoleId);
873
874 resourcePermissionPersistence.update(resourcePermission);
875 }
876
877 roleLocalService.deleteRole(fromRoleId);
878
879 PermissionCacheUtil.clearCache();
880 }
881
882
894 @Override
895 public void reassignPermissions(long resourcePermissionId, long toRoleId)
896 throws PortalException, SystemException {
897
898 ResourcePermission resourcePermission = getResourcePermission(
899 resourcePermissionId);
900
901 long companyId = resourcePermission.getCompanyId();
902 String name = resourcePermission.getName();
903 int scope = resourcePermission.getScope();
904 String primKey = resourcePermission.getPrimKey();
905 long fromRoleId = resourcePermission.getRoleId();
906
907 Role toRole = roleLocalService.getRole(toRoleId);
908
909 List<String> actionIds = null;
910
911 if (toRole.getType() == RoleConstants.TYPE_REGULAR) {
912 actionIds = ResourceActionsUtil.getModelResourceActions(name);
913 }
914 else {
915 actionIds = ResourceActionsUtil.getModelResourceGroupDefaultActions(
916 name);
917 }
918
919 setResourcePermissions(
920 companyId, name, scope, primKey, toRoleId,
921 actionIds.toArray(new String[actionIds.size()]));
922
923 resourcePermissionPersistence.remove(resourcePermissionId);
924
925 List<ResourcePermission> resourcePermissions =
926 getRoleResourcePermissions(fromRoleId);
927
928 if (resourcePermissions.isEmpty()) {
929 roleLocalService.deleteRole(fromRoleId);
930 }
931 }
932
933
955 @Override
956 public void removeResourcePermission(
957 long companyId, String name, int scope, String primKey, long roleId,
958 String actionId)
959 throws PortalException, SystemException {
960
961 updateResourcePermission(
962 companyId, name, scope, primKey, roleId, 0, new String[] {actionId},
963 ResourcePermissionConstants.OPERATOR_REMOVE);
964
965 PermissionCacheUtil.clearCache();
966 }
967
968
984 @Override
985 public void removeResourcePermissions(
986 long companyId, String name, int scope, long roleId,
987 String actionId)
988 throws PortalException, SystemException {
989
990 List<ResourcePermission> resourcePermissions =
991 resourcePermissionPersistence.findByC_N_S(companyId, name, scope);
992
993 for (ResourcePermission resourcePermission : resourcePermissions) {
994 updateResourcePermission(
995 companyId, name, scope, resourcePermission.getPrimKey(), roleId,
996 0, new String[] {actionId},
997 ResourcePermissionConstants.OPERATOR_REMOVE);
998 }
999
1000 PermissionCacheUtil.clearCache();
1001 }
1002
1003
1033 @Override
1034 public void setOwnerResourcePermissions(
1035 long companyId, String name, int scope, String primKey, long roleId,
1036 long ownerId, String[] actionIds)
1037 throws PortalException, SystemException {
1038
1039 updateResourcePermission(
1040 companyId, name, scope, primKey, roleId, ownerId, actionIds,
1041 ResourcePermissionConstants.OPERATOR_SET);
1042 }
1043
1044
1071 @Override
1072 public void setResourcePermissions(
1073 long companyId, String name, int scope, String primKey, long roleId,
1074 String[] actionIds)
1075 throws PortalException, SystemException {
1076
1077 updateResourcePermission(
1078 companyId, name, scope, primKey, roleId, 0, actionIds,
1079 ResourcePermissionConstants.OPERATOR_SET);
1080 }
1081
1082
1108 @Override
1109 public void setResourcePermissions(
1110 long companyId, String name, int scope, String primKey,
1111 Map<Long, String[]> roleIdsToActionIds)
1112 throws PortalException, SystemException {
1113
1114 updateResourcePermission(
1115 companyId, name, scope, primKey, 0, roleIdsToActionIds);
1116 }
1117
1118 protected void doUpdateResourcePermission(
1119 long companyId, String name, int scope, String primKey,
1120 long ownerId, long roleId, String[] actionIds, int operator,
1121 boolean fetch)
1122 throws PortalException, SystemException {
1123
1124 ResourcePermission resourcePermission = null;
1125
1126 Map<Long, ResourcePermission> resourcePermissionsMap =
1127 ResourcePermissionsThreadLocal.getResourcePermissions();
1128
1129 if (resourcePermissionsMap != null) {
1130 resourcePermission = resourcePermissionsMap.get(roleId);
1131 }
1132 else if (fetch) {
1133 resourcePermission = resourcePermissionPersistence.fetchByC_N_S_P_R(
1134 companyId, name, scope, primKey, roleId);
1135 }
1136
1137 if (resourcePermission == null) {
1138 if (((operator == ResourcePermissionConstants.OPERATOR_ADD) ||
1139 (operator == ResourcePermissionConstants.OPERATOR_SET)) &&
1140 (actionIds.length == 0)) {
1141
1142 return;
1143 }
1144
1145 if (operator == ResourcePermissionConstants.OPERATOR_REMOVE) {
1146 return;
1147 }
1148
1149 long resourcePermissionId = counterLocalService.increment(
1150 ResourcePermission.class.getName());
1151
1152 resourcePermission = resourcePermissionPersistence.create(
1153 resourcePermissionId);
1154
1155 resourcePermission.setCompanyId(companyId);
1156 resourcePermission.setName(name);
1157 resourcePermission.setScope(scope);
1158 resourcePermission.setPrimKey(primKey);
1159 resourcePermission.setRoleId(roleId);
1160 resourcePermission.setOwnerId(ownerId);
1161 }
1162
1163 List<String> unsupportedActionIds = Collections.emptyList();
1164
1165 if (((operator == ResourcePermissionConstants.OPERATOR_ADD) ||
1166 (operator == ResourcePermissionConstants.OPERATOR_SET)) &&
1167 isGuestRoleId(companyId, roleId)) {
1168
1169 unsupportedActionIds =
1170 ResourceActionsUtil.getResourceGuestUnsupportedActions(
1171 name, name);
1172 }
1173
1174 long actionIdsLong = resourcePermission.getActionIds();
1175
1176 if (operator == ResourcePermissionConstants.OPERATOR_SET) {
1177 actionIdsLong = 0;
1178 }
1179
1180 for (String actionId : actionIds) {
1181 if (actionId == null) {
1182 break;
1183 }
1184
1185 if (unsupportedActionIds.contains(actionId)) {
1186 throw new PrincipalException(
1187 actionId + "is not supported by role " + roleId);
1188 }
1189
1190 ResourceAction resourceAction =
1191 resourceActionLocalService.getResourceAction(name, actionId);
1192
1193 if ((operator == ResourcePermissionConstants.OPERATOR_ADD) ||
1194 (operator == ResourcePermissionConstants.OPERATOR_SET)) {
1195
1196 actionIdsLong |= resourceAction.getBitwiseValue();
1197 }
1198 else {
1199 actionIdsLong =
1200 actionIdsLong & (~resourceAction.getBitwiseValue());
1201 }
1202 }
1203
1204 resourcePermission.setActionIds(actionIdsLong);
1205
1206 resourcePermissionPersistence.update(resourcePermission);
1207
1208 PermissionCacheUtil.clearCache();
1209
1210 SearchEngineUtil.updatePermissionFields(name, primKey);
1211 }
1212
1213 protected void doUpdateResourcePermission(
1214 long companyId, String name, int scope, String primKey,
1215 long ownerId, Map<Long, String[]> roleIdsToActionIds)
1216 throws PortalException, SystemException {
1217
1218 boolean flushEnabled = PermissionThreadLocal.isFlushEnabled();
1219
1220 PermissionThreadLocal.setIndexEnabled(false);
1221
1222 try {
1223 long[] roleIds = ArrayUtil.toLongArray(roleIdsToActionIds.keySet());
1224
1225 List<ResourcePermission> resourcePermissions =
1226 resourcePermissionPersistence.findByC_N_S_P_R(
1227 companyId, name, scope, primKey, roleIds);
1228
1229 for (ResourcePermission resourcePermission : resourcePermissions) {
1230 long roleId = resourcePermission.getRoleId();
1231 String[] actionIds = roleIdsToActionIds.remove(roleId);
1232
1233 doUpdateResourcePermission(
1234 companyId, name, scope, primKey, ownerId, roleId, actionIds,
1235 ResourcePermissionConstants.OPERATOR_SET, true);
1236 }
1237
1238 if (roleIdsToActionIds.isEmpty()) {
1239 return;
1240 }
1241
1242 for (Map.Entry<Long, String[]> entry :
1243 roleIdsToActionIds.entrySet()) {
1244
1245 long roleId = entry.getKey();
1246 String[] actionIds = entry.getValue();
1247
1248 doUpdateResourcePermission(
1249 companyId, name, scope, primKey, ownerId, roleId, actionIds,
1250 ResourcePermissionConstants.OPERATOR_SET, false);
1251 }
1252 }
1253 finally {
1254 PermissionThreadLocal.setIndexEnabled(flushEnabled);
1255
1256 PermissionCacheUtil.clearCache();
1257
1258 SearchEngineUtil.updatePermissionFields(name, primKey);
1259 }
1260 }
1261
1262 protected boolean isGuestRoleId(long companyId, long roleId)
1263 throws PortalException, SystemException {
1264
1265 Role guestRole = roleLocalService.getRole(
1266 companyId, RoleConstants.GUEST);
1267
1268 if (roleId == guestRole.getRoleId()) {
1269 return true;
1270 }
1271
1272 return false;
1273 }
1274
1275
1303 protected void updateResourcePermission(
1304 long companyId, String name, int scope, String primKey, long roleId,
1305 long ownerId, String[] actionIds, int operator)
1306 throws PortalException, SystemException {
1307
1308 DB db = DBFactoryUtil.getDB();
1309
1310 String dbType = db.getType();
1311
1312 if (!dbType.equals(DB.TYPE_HYPERSONIC)) {
1313 doUpdateResourcePermission(
1314 companyId, name, scope, primKey, ownerId, roleId, actionIds,
1315 operator, true);
1316
1317 return;
1318 }
1319
1320 StringBundler sb = new StringBundler(9);
1321
1322 sb.append(companyId);
1323 sb.append(StringPool.POUND);
1324 sb.append(name);
1325 sb.append(StringPool.POUND);
1326 sb.append(scope);
1327 sb.append(StringPool.POUND);
1328 sb.append(primKey);
1329 sb.append(StringPool.POUND);
1330 sb.append(roleId);
1331
1332 Class<?> clazz = getClass();
1333
1334 String groupName = clazz.getName();
1335
1336 String key = sb.toString();
1337
1338 Lock lock = LockRegistry.allocateLock(groupName, key);
1339
1340 lock.lock();
1341
1342 try {
1343 doUpdateResourcePermission(
1344 companyId, name, scope, primKey, ownerId, roleId, actionIds,
1345 operator, true);
1346 }
1347 finally {
1348 lock.unlock();
1349
1350 LockRegistry.freeLock(groupName, key);
1351 }
1352 }
1353
1354
1377 protected void updateResourcePermission(
1378 long companyId, String name, int scope, String primKey,
1379 long ownerId, Map<Long, String[]> roleIdsToActionIds)
1380 throws PortalException, SystemException {
1381
1382 DB db = DBFactoryUtil.getDB();
1383
1384 String dbType = db.getType();
1385
1386 if (!dbType.equals(DB.TYPE_HYPERSONIC)) {
1387 doUpdateResourcePermission(
1388 companyId, name, scope, primKey, ownerId, roleIdsToActionIds);
1389
1390 return;
1391 }
1392
1393 StringBundler sb = new StringBundler(9);
1394
1395 sb.append(companyId);
1396 sb.append(StringPool.POUND);
1397 sb.append(name);
1398 sb.append(StringPool.POUND);
1399 sb.append(scope);
1400 sb.append(StringPool.POUND);
1401 sb.append(primKey);
1402 sb.append(StringPool.POUND);
1403 sb.append(StringUtil.merge(roleIdsToActionIds.keySet()));
1404
1405 Class<?> clazz = getClass();
1406
1407 String groupName = clazz.getName();
1408
1409 String key = sb.toString();
1410
1411 Lock lock = LockRegistry.allocateLock(groupName, key);
1412
1413 lock.lock();
1414
1415 try {
1416 doUpdateResourcePermission(
1417 companyId, name, scope, primKey, ownerId, roleIdsToActionIds);
1418 }
1419 finally {
1420 lock.unlock();
1421
1422 LockRegistry.freeLock(groupName, key);
1423 }
1424 }
1425
1426 private static final String _FIND_MISSING_RESOURCE_PERMISSIONS =
1427 ResourcePermissionLocalServiceImpl.class.getName() +
1428 ".findMissingResourcePermissions";
1429
1430 private static final String _UPDATE_ACTION_IDS =
1431 ResourcePermissionLocalServiceImpl.class.getName() + ".updateActionIds";
1432
1433 }