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.permission.PermissionCacheUtil;
041 import com.liferay.portal.security.permission.PermissionThreadLocal;
042 import com.liferay.portal.security.permission.ResourceActionsUtil;
043 import com.liferay.portal.service.base.ResourcePermissionLocalServiceBaseImpl;
044 import com.liferay.portal.util.PortalUtil;
045 import com.liferay.portal.util.PropsValues;
046 import com.liferay.portal.util.ResourcePermissionsThreadLocal;
047 import com.liferay.util.dao.orm.CustomSQLUtil;
048
049 import java.util.ArrayList;
050 import java.util.Collection;
051 import java.util.Collections;
052 import java.util.HashMap;
053 import java.util.HashSet;
054 import java.util.List;
055 import java.util.Map;
056 import java.util.Set;
057 import java.util.concurrent.locks.Lock;
058
059
073 public class ResourcePermissionLocalServiceImpl
074 extends ResourcePermissionLocalServiceBaseImpl {
075
076
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 List<ResourcePermission> resourcePermissions =
355 resourcePermissionPersistence.findByC_N_S_P_R(
356 companyId, name, scope, primKey, roleId);
357
358 if (resourcePermissions.isEmpty()) {
359 return Collections.emptyList();
360 }
361
362 ResourcePermission resourcePermission = resourcePermissions.get(0);
363
364 List<String> availableActionIds = new ArrayList<String>(
365 actionIds.size());
366
367 for (String actionId : actionIds) {
368 ResourceAction resourceAction =
369 resourceActionLocalService.getResourceAction(name, actionId);
370
371 if (hasActionId(resourcePermission, resourceAction)) {
372 availableActionIds.add(actionId);
373 }
374 }
375
376 return availableActionIds;
377 }
378
379 @Override
380 public Map<Long, Set<String>> getAvailableResourcePermissionActionIds(
381 long companyId, String name, int scope, String primKey,
382 long[] roleIds, Collection<String> actionIds)
383 throws PortalException, SystemException {
384
385 List<ResourcePermission> resourcePermissions =
386 resourcePermissionPersistence.findByC_N_S_P_R(
387 companyId, name, scope, primKey, roleIds);
388
389 if (resourcePermissions.isEmpty()) {
390 return Collections.emptyMap();
391 }
392
393 Map<Long, Set<String>> roleIdsToActionIds =
394 new HashMap<Long, Set<String>>();
395
396 for (ResourcePermission resourcePermission : resourcePermissions) {
397 long roleId = resourcePermission.getRoleId();
398
399 Set<String> availableActionIds = roleIdsToActionIds.get(roleId);
400
401 if (availableActionIds != null) {
402 continue;
403 }
404
405 availableActionIds = new HashSet<String>();
406
407 roleIdsToActionIds.put(roleId, availableActionIds);
408
409 for (String actionId : actionIds) {
410 ResourceAction resourceAction =
411 resourceActionLocalService.getResourceAction(
412 name, actionId);
413
414 if (hasActionId(resourcePermission, resourceAction)) {
415 availableActionIds.add(actionId);
416 }
417 }
418 }
419
420 return roleIdsToActionIds;
421 }
422
423
438 @Override
439 public ResourcePermission getResourcePermission(
440 long companyId, String name, int scope, String primKey, long roleId)
441 throws PortalException, SystemException {
442
443 List<ResourcePermission> resourcePermissions =
444 resourcePermissionPersistence.findByC_N_S_P_R(
445 companyId, name, scope, primKey, roleId);
446
447 if (!resourcePermissions.isEmpty()) {
448 return resourcePermissions.get(0);
449 }
450
451 StringBundler sb = new StringBundler(11);
452
453 sb.append("No ResourcePermission exists with the key {companyId=");
454 sb.append(companyId);
455 sb.append(", name=");
456 sb.append(name);
457 sb.append(", scope=");
458 sb.append(scope);
459 sb.append(", primKey=");
460 sb.append(primKey);
461 sb.append(", roleId=");
462 sb.append(roleId);
463 sb.append("}");
464
465 throw new NoSuchResourcePermissionException(sb.toString());
466 }
467
468
479 @Override
480 public List<ResourcePermission> getResourcePermissions(
481 long companyId, String name, int scope, String primKey)
482 throws SystemException {
483
484 return resourcePermissionPersistence.findByC_N_S_P(
485 companyId, name, scope, primKey);
486 }
487
488
499 @Override
500 public int getResourcePermissionsCount(
501 long companyId, String name, int scope, String primKey)
502 throws SystemException {
503
504 return resourcePermissionPersistence.countByC_N_S_P(
505 companyId, name, scope, primKey);
506 }
507
508
519 @Override
520 public List<ResourcePermission> getResourceResourcePermissions(
521 long companyId, long groupId, String name, String primKey)
522 throws SystemException {
523
524 return resourcePermissionFinder.findByResource(
525 companyId, groupId, name, primKey);
526 }
527
528
535 @Override
536 public List<ResourcePermission> getRoleResourcePermissions(long roleId)
537 throws SystemException {
538
539 return resourcePermissionPersistence.findByRoleId(roleId);
540 }
541
542
563 @Override
564 public List<ResourcePermission> getRoleResourcePermissions(
565 long roleId, int[] scopes, int start, int end)
566 throws SystemException {
567
568 return resourcePermissionFinder.findByR_S(roleId, scopes, start, end);
569 }
570
571
588 @Override
589 public List<ResourcePermission> getScopeResourcePermissions(int[] scopes)
590 throws SystemException {
591
592 return resourcePermissionPersistence.findByScope(scopes);
593 }
594
595
606 @Override
607 public boolean hasActionId(
608 ResourcePermission resourcePermission, ResourceAction resourceAction) {
609
610 long actionIds = resourcePermission.getActionIds();
611 long bitwiseValue = resourceAction.getBitwiseValue();
612
613 if ((actionIds & bitwiseValue) == bitwiseValue) {
614 return true;
615 }
616 else {
617 return false;
618 }
619 }
620
621
642 @Override
643 public boolean hasResourcePermission(
644 List<Resource> resources, long[] roleIds, String actionId)
645 throws PortalException, SystemException {
646
647
648
649
650
651
652
653 for (int i = resources.size() - 1; i >= 0; i--) {
654 Resource resource = resources.get(i);
655
656 if (hasResourcePermission(
657 resource.getCompanyId(), resource.getName(),
658 resource.getScope(), resource.getPrimKey(), roleIds,
659 actionId)) {
660
661 return true;
662 }
663 }
664
665 return false;
666 }
667
668
691 @Override
692 public boolean hasResourcePermission(
693 long companyId, String name, int scope, String primKey, long roleId,
694 String actionId)
695 throws PortalException, SystemException {
696
697 return hasResourcePermission(
698 companyId, name, scope, primKey, new long[] {roleId}, actionId);
699 }
700
701
725 @Override
726 public boolean hasResourcePermission(
727 long companyId, String name, int scope, String primKey,
728 long[] roleIds, String actionId)
729 throws PortalException, SystemException {
730
731 ResourceAction resourceAction =
732 resourceActionLocalService.getResourceAction(name, actionId);
733
734 DB db = DBFactoryUtil.getDB();
735
736 String dbType = db.getType();
737
738 if ((roleIds.length >
739 PropsValues.
740 PERMISSIONS_ROLE_RESOURCE_PERMISSION_QUERY_THRESHOLD) &&
741 !dbType.equals(DB.TYPE_DERBY) &&
742 !dbType.equals(DB.TYPE_JDATASTORE) &&
743 !dbType.equals(DB.TYPE_SAP)) {
744
745 int count = resourcePermissionFinder.countByC_N_S_P_R_A(
746 companyId, name, scope, primKey, roleIds,
747 resourceAction.getBitwiseValue());
748
749 if (count > 0) {
750 return true;
751 }
752 }
753 else {
754 List<ResourcePermission> resourcePermissions =
755 resourcePermissionPersistence.findByC_N_S_P_R(
756 companyId, name, scope, primKey, roleIds);
757
758 if (resourcePermissions.isEmpty()) {
759 return false;
760 }
761
762 for (ResourcePermission resourcePermission : resourcePermissions) {
763 if (hasActionId(resourcePermission, resourceAction)) {
764 return true;
765 }
766 }
767
768 }
769
770 return false;
771 }
772
773 @Override
774 public boolean[] hasResourcePermissions(
775 long companyId, String name, int scope, String primKey,
776 long[] roleIds, String actionId)
777 throws PortalException, SystemException {
778
779 ResourceAction resourceAction =
780 resourceActionLocalService.getResourceAction(name, actionId);
781
782 List<ResourcePermission> resourcePermissions =
783 resourcePermissionPersistence.findByC_N_S_P_R(
784 companyId, name, scope, primKey, roleIds);
785
786 boolean[] hasResourcePermissions = new boolean[roleIds.length];
787
788 if (resourcePermissions.isEmpty()) {
789 return hasResourcePermissions;
790 }
791
792 for (ResourcePermission resourcePermission : resourcePermissions) {
793 if (hasActionId(resourcePermission, resourceAction)) {
794 long roleId = resourcePermission.getRoleId();
795
796 for (int i = 0; i < roleIds.length; i++) {
797 if (roleIds[i] == roleId) {
798 hasResourcePermissions[i] = true;
799 }
800 }
801 }
802 }
803
804 return hasResourcePermissions;
805 }
806
807
829 @Override
830 public boolean hasScopeResourcePermission(
831 long companyId, String name, int scope, long roleId,
832 String actionId)
833 throws PortalException, SystemException {
834
835 List<ResourcePermission> resourcePermissions =
836 resourcePermissionPersistence.findByC_N_S(companyId, name, scope);
837
838 for (ResourcePermission resourcePermission : resourcePermissions) {
839 if (hasResourcePermission(
840 companyId, name, scope, resourcePermission.getPrimKey(),
841 roleId, actionId)) {
842
843 return true;
844 }
845 }
846
847 return false;
848 }
849
850
859 @Override
860 public void mergePermissions(long fromRoleId, long toRoleId)
861 throws PortalException, SystemException {
862
863 Role fromRole = rolePersistence.findByPrimaryKey(fromRoleId);
864 Role toRole = rolePersistence.findByPrimaryKey(toRoleId);
865
866 if (fromRole.getType() != toRole.getType()) {
867 throw new PortalException("Role types are mismatched");
868 }
869 else if (PortalUtil.isSystemRole(toRole.getName())) {
870 throw new PortalException("Cannot move permissions to system role");
871 }
872 else if (PortalUtil.isSystemRole(fromRole.getName())) {
873 throw new PortalException(
874 "Cannot move permissions from system role");
875 }
876
877 List<ResourcePermission> resourcePermissions =
878 getRoleResourcePermissions(fromRoleId);
879
880 for (ResourcePermission resourcePermission : resourcePermissions) {
881 resourcePermission.setRoleId(toRoleId);
882
883 resourcePermissionPersistence.update(resourcePermission, false);
884 }
885
886 roleLocalService.deleteRole(fromRoleId);
887
888 PermissionCacheUtil.clearCache();
889 }
890
891
903 @Override
904 public void reassignPermissions(long resourcePermissionId, long toRoleId)
905 throws PortalException, SystemException {
906
907 ResourcePermission resourcePermission = getResourcePermission(
908 resourcePermissionId);
909
910 long companyId = resourcePermission.getCompanyId();
911 String name = resourcePermission.getName();
912 int scope = resourcePermission.getScope();
913 String primKey = resourcePermission.getPrimKey();
914 long fromRoleId = resourcePermission.getRoleId();
915
916 Role toRole = roleLocalService.getRole(toRoleId);
917
918 List<String> actionIds = null;
919
920 if (toRole.getType() == RoleConstants.TYPE_REGULAR) {
921 actionIds = ResourceActionsUtil.getModelResourceActions(name);
922 }
923 else {
924 actionIds = ResourceActionsUtil.getModelResourceGroupDefaultActions(
925 name);
926 }
927
928 setResourcePermissions(
929 companyId, name, scope, primKey, toRoleId,
930 actionIds.toArray(new String[actionIds.size()]));
931
932 resourcePermissionPersistence.remove(resourcePermissionId);
933
934 List<ResourcePermission> resourcePermissions =
935 getRoleResourcePermissions(fromRoleId);
936
937 if (resourcePermissions.isEmpty()) {
938 roleLocalService.deleteRole(fromRoleId);
939 }
940 }
941
942
964 @Override
965 public void removeResourcePermission(
966 long companyId, String name, int scope, String primKey, long roleId,
967 String actionId)
968 throws PortalException, SystemException {
969
970 updateResourcePermission(
971 companyId, name, scope, primKey, roleId, 0, new String[] {actionId},
972 ResourcePermissionConstants.OPERATOR_REMOVE);
973
974 PermissionCacheUtil.clearCache();
975 }
976
977
993 @Override
994 public void removeResourcePermissions(
995 long companyId, String name, int scope, long roleId,
996 String actionId)
997 throws PortalException, SystemException {
998
999 List<ResourcePermission> resourcePermissions =
1000 resourcePermissionPersistence.findByC_N_S(companyId, name, scope);
1001
1002 for (ResourcePermission resourcePermission : resourcePermissions) {
1003 updateResourcePermission(
1004 companyId, name, scope, resourcePermission.getPrimKey(), roleId,
1005 0, new String[] {actionId},
1006 ResourcePermissionConstants.OPERATOR_REMOVE);
1007 }
1008
1009 PermissionCacheUtil.clearCache();
1010 }
1011
1012
1042 @Override
1043 public void setOwnerResourcePermissions(
1044 long companyId, String name, int scope, String primKey, long roleId,
1045 long ownerId, String[] actionIds)
1046 throws PortalException, SystemException {
1047
1048 updateResourcePermission(
1049 companyId, name, scope, primKey, roleId, ownerId, actionIds,
1050 ResourcePermissionConstants.OPERATOR_SET);
1051 }
1052
1053
1080 @Override
1081 public void setResourcePermissions(
1082 long companyId, String name, int scope, String primKey, long roleId,
1083 String[] actionIds)
1084 throws PortalException, SystemException {
1085
1086 updateResourcePermission(
1087 companyId, name, scope, primKey, roleId, 0, actionIds,
1088 ResourcePermissionConstants.OPERATOR_SET);
1089 }
1090
1091
1117 @Override
1118 public void setResourcePermissions(
1119 long companyId, String name, int scope, String primKey,
1120 Map<Long, String[]> roleIdsToActionIds)
1121 throws PortalException, SystemException {
1122
1123 updateResourcePermission(
1124 companyId, name, scope, primKey, 0, roleIdsToActionIds);
1125 }
1126
1127 protected void doUpdateResourcePermission(
1128 long companyId, String name, int scope, String primKey,
1129 long ownerId, long roleId, String[] actionIds, int operator,
1130 boolean fetch)
1131 throws PortalException, SystemException {
1132
1133 ResourcePermission resourcePermission = null;
1134
1135 Map<Long, ResourcePermission> resourcePermissionsMap =
1136 ResourcePermissionsThreadLocal.getResourcePermissions();
1137
1138 if (resourcePermissionsMap != null) {
1139 resourcePermission = resourcePermissionsMap.get(roleId);
1140 }
1141 else if (fetch) {
1142 List<ResourcePermission> resourcePermissions =
1143 resourcePermissionPersistence.findByC_N_S_P_R(
1144 companyId, name, scope, primKey, roleId);
1145
1146 if (!resourcePermissions.isEmpty()) {
1147 resourcePermission = resourcePermissions.get(0);
1148 }
1149 }
1150
1151 if (resourcePermission == null) {
1152 if (((operator == ResourcePermissionConstants.OPERATOR_ADD) ||
1153 (operator == ResourcePermissionConstants.OPERATOR_SET)) &&
1154 (actionIds.length == 0)) {
1155
1156 return;
1157 }
1158
1159 if (operator == ResourcePermissionConstants.OPERATOR_REMOVE) {
1160 return;
1161 }
1162
1163 long resourcePermissionId = counterLocalService.increment(
1164 ResourcePermission.class.getName());
1165
1166 resourcePermission = resourcePermissionPersistence.create(
1167 resourcePermissionId);
1168
1169 resourcePermission.setCompanyId(companyId);
1170 resourcePermission.setName(name);
1171 resourcePermission.setScope(scope);
1172 resourcePermission.setPrimKey(primKey);
1173 resourcePermission.setRoleId(roleId);
1174 resourcePermission.setOwnerId(ownerId);
1175 }
1176
1177 long actionIdsLong = resourcePermission.getActionIds();
1178
1179 if (operator == ResourcePermissionConstants.OPERATOR_SET) {
1180 actionIdsLong = 0;
1181 }
1182
1183 for (String actionId : actionIds) {
1184 if (actionId == null) {
1185 break;
1186 }
1187
1188 ResourceAction resourceAction =
1189 resourceActionLocalService.getResourceAction(name, actionId);
1190
1191 if ((operator == ResourcePermissionConstants.OPERATOR_ADD) ||
1192 (operator == ResourcePermissionConstants.OPERATOR_SET)) {
1193
1194 actionIdsLong |= resourceAction.getBitwiseValue();
1195 }
1196 else {
1197 actionIdsLong =
1198 actionIdsLong & (~resourceAction.getBitwiseValue());
1199 }
1200 }
1201
1202 resourcePermission.setActionIds(actionIdsLong);
1203
1204 resourcePermissionPersistence.update(resourcePermission, false);
1205
1206 PermissionCacheUtil.clearCache();
1207
1208 SearchEngineUtil.updatePermissionFields(name, primKey);
1209 }
1210
1211 protected void doUpdateResourcePermission(
1212 long companyId, String name, int scope, String primKey,
1213 long ownerId, Map<Long, String[]> roleIdsToActionIds)
1214 throws PortalException, SystemException {
1215
1216 boolean flushEnabled = PermissionThreadLocal.isFlushEnabled();
1217
1218 PermissionThreadLocal.setIndexEnabled(false);
1219
1220 try {
1221 long[] roleIds = ArrayUtil.toLongArray(roleIdsToActionIds.keySet());
1222
1223 List<ResourcePermission> resourcePermissions =
1224 resourcePermissionPersistence.findByC_N_S_P_R(
1225 companyId, name, scope, primKey, roleIds);
1226
1227 for (ResourcePermission resourcePermission : resourcePermissions) {
1228 long roleId = resourcePermission.getRoleId();
1229 String[] actionIds = roleIdsToActionIds.remove(roleId);
1230
1231 doUpdateResourcePermission(
1232 companyId, name, scope, primKey, ownerId, roleId, actionIds,
1233 ResourcePermissionConstants.OPERATOR_SET, true);
1234 }
1235
1236 if (roleIdsToActionIds.isEmpty()) {
1237 return;
1238 }
1239
1240 for (Map.Entry<Long, String[]> entry :
1241 roleIdsToActionIds.entrySet()) {
1242
1243 long roleId = entry.getKey();
1244 String[] actionIds = entry.getValue();
1245
1246 doUpdateResourcePermission(
1247 companyId, name, scope, primKey, ownerId, roleId, actionIds,
1248 ResourcePermissionConstants.OPERATOR_SET, false);
1249 }
1250 }
1251 finally {
1252 PermissionThreadLocal.setIndexEnabled(flushEnabled);
1253
1254 PermissionCacheUtil.clearCache();
1255
1256 SearchEngineUtil.updatePermissionFields(name, primKey);
1257 }
1258 }
1259
1260
1288 protected void updateResourcePermission(
1289 long companyId, String name, int scope, String primKey, long roleId,
1290 long ownerId, String[] actionIds, int operator)
1291 throws PortalException, SystemException {
1292
1293 DB db = DBFactoryUtil.getDB();
1294
1295 String dbType = db.getType();
1296
1297 if (!dbType.equals(DB.TYPE_HYPERSONIC)) {
1298 doUpdateResourcePermission(
1299 companyId, name, scope, primKey, ownerId, roleId, actionIds,
1300 operator, true);
1301
1302 return;
1303 }
1304
1305 StringBundler sb = new StringBundler(9);
1306
1307 sb.append(companyId);
1308 sb.append(StringPool.POUND);
1309 sb.append(name);
1310 sb.append(StringPool.POUND);
1311 sb.append(scope);
1312 sb.append(StringPool.POUND);
1313 sb.append(primKey);
1314 sb.append(StringPool.POUND);
1315 sb.append(roleId);
1316
1317 Class<?> clazz = getClass();
1318
1319 String groupName = clazz.getName();
1320
1321 String key = sb.toString();
1322
1323 Lock lock = LockRegistry.allocateLock(groupName, key);
1324
1325 lock.lock();
1326
1327 try {
1328 doUpdateResourcePermission(
1329 companyId, name, scope, primKey, ownerId, roleId, actionIds,
1330 operator, true);
1331 }
1332 finally {
1333 lock.unlock();
1334
1335 LockRegistry.freeLock(groupName, key);
1336 }
1337 }
1338
1339
1362 protected void updateResourcePermission(
1363 long companyId, String name, int scope, String primKey,
1364 long ownerId, Map<Long, String[]> roleIdsToActionIds)
1365 throws PortalException, SystemException {
1366
1367 DB db = DBFactoryUtil.getDB();
1368
1369 String dbType = db.getType();
1370
1371 if (!dbType.equals(DB.TYPE_HYPERSONIC)) {
1372 doUpdateResourcePermission(
1373 companyId, name, scope, primKey, ownerId, roleIdsToActionIds);
1374
1375 return;
1376 }
1377
1378 StringBundler sb = new StringBundler(9);
1379
1380 sb.append(companyId);
1381 sb.append(StringPool.POUND);
1382 sb.append(name);
1383 sb.append(StringPool.POUND);
1384 sb.append(scope);
1385 sb.append(StringPool.POUND);
1386 sb.append(primKey);
1387 sb.append(StringPool.POUND);
1388 sb.append(StringUtil.merge(roleIdsToActionIds.keySet()));
1389
1390 Class<?> clazz = getClass();
1391
1392 String groupName = clazz.getName();
1393
1394 String key = sb.toString();
1395
1396 Lock lock = LockRegistry.allocateLock(groupName, key);
1397
1398 lock.lock();
1399
1400 try {
1401 doUpdateResourcePermission(
1402 companyId, name, scope, primKey, ownerId, roleIdsToActionIds);
1403 }
1404 finally {
1405 lock.unlock();
1406
1407 LockRegistry.freeLock(groupName, key);
1408 }
1409 }
1410
1411 private static final String _FIND_MISSING_RESOURCE_PERMISSIONS =
1412 ResourcePermissionLocalServiceImpl.class.getName() +
1413 ".findMissingResourcePermissions";
1414
1415 private static final String _UPDATE_ACTION_IDS =
1416 ResourcePermissionLocalServiceImpl.class.getName() + ".updateActionIds";
1417
1418 }