001    /**
002     * Copyright (c) 2000-2011 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.NoSuchResourceBlockException;
018    import com.liferay.portal.ResourceBlocksNotSupportedException;
019    import com.liferay.portal.kernel.exception.PortalException;
020    import com.liferay.portal.kernel.exception.SystemException;
021    import com.liferay.portal.kernel.log.Log;
022    import com.liferay.portal.kernel.log.LogFactoryUtil;
023    import com.liferay.portal.kernel.util.Digester;
024    import com.liferay.portal.kernel.util.DigesterUtil;
025    import com.liferay.portal.kernel.util.ListUtil;
026    import com.liferay.portal.model.AuditedModel;
027    import com.liferay.portal.model.GroupedModel;
028    import com.liferay.portal.model.PermissionedModel;
029    import com.liferay.portal.model.PersistedModel;
030    import com.liferay.portal.model.ResourceAction;
031    import com.liferay.portal.model.ResourceBlock;
032    import com.liferay.portal.model.ResourceBlockConstants;
033    import com.liferay.portal.model.ResourceBlockPermissionsContainer;
034    import com.liferay.portal.model.ResourceTypePermission;
035    import com.liferay.portal.security.permission.PermissionCacheUtil;
036    import com.liferay.portal.security.permission.PermissionThreadLocal;
037    import com.liferay.portal.security.permission.ResourceBlockIdsBag;
038    import com.liferay.portal.service.PersistedModelLocalService;
039    import com.liferay.portal.service.PersistedModelLocalServiceRegistryUtil;
040    import com.liferay.portal.service.base.ResourceBlockLocalServiceBaseImpl;
041    
042    import java.nio.ByteBuffer;
043    
044    import java.util.ArrayList;
045    import java.util.List;
046    import java.util.Map;
047    import java.util.SortedMap;
048    
049    /**
050     * Manages the creation and upkeep of resource blocks and the resources they
051     * contain.
052     *
053     * @author Connor McKay
054     */
055    public class ResourceBlockLocalServiceImpl
056            extends ResourceBlockLocalServiceBaseImpl {
057    
058            private static Log _log = LogFactoryUtil.getLog(
059                    ResourceBlockLocalServiceImpl.class);
060    
061            public void addCompanyScopePermission(
062                            long companyId, String name, long roleId, String actionId)
063                    throws PortalException, SystemException {
064    
065                    updateCompanyScopePermissions(
066                            companyId, name, roleId, getActionId(name, actionId),
067                            ResourceBlockConstants.OPERATOR_ADD);
068            }
069    
070            public void addCompanyScopePermissions(
071                            long companyId, String name, long roleId, long actionIdsLong)
072                    throws SystemException {
073    
074                    updateCompanyScopePermissions(
075                            companyId, name, roleId, actionIdsLong,
076                            ResourceBlockConstants.OPERATOR_ADD);
077            }
078    
079            public void addGroupScopePermission(
080                            long companyId, long groupId, String name, long roleId,
081                            String actionId)
082                    throws PortalException, SystemException {
083    
084                    updateGroupScopePermissions(
085                            companyId, groupId, name, roleId, getActionId(name, actionId),
086                            ResourceBlockConstants.OPERATOR_ADD);
087            }
088    
089            public void addGroupScopePermissions(
090                            long companyId, long groupId, String name, long roleId,
091                            long actionIdsLong)
092                    throws SystemException {
093    
094                    updateGroupScopePermissions(
095                            companyId, groupId, name, roleId, actionIdsLong,
096                            ResourceBlockConstants.OPERATOR_ADD);
097            }
098    
099            public void addIndividualScopePermission(
100                            long companyId, long groupId, String name, long primKey,
101                            long roleId, String actionId)
102                    throws PortalException, SystemException {
103    
104                    PermissionedModel permissionedModel = getPermissionedModel(
105                            name, primKey);
106    
107                    updateIndividualScopePermissions(
108                            companyId, groupId, name, permissionedModel, roleId,
109                            getActionId(name, actionId), ResourceBlockConstants.OPERATOR_ADD);
110            }
111    
112            public void addIndividualScopePermission(
113                            long companyId, long groupId, String name,
114                            PermissionedModel permissionedModel, long roleId, String actionId)
115                    throws PortalException, SystemException {
116    
117                    updateIndividualScopePermissions(
118                            companyId, groupId, name, permissionedModel, roleId,
119                            getActionId(name, actionId), ResourceBlockConstants.OPERATOR_ADD);
120            }
121    
122            public void addIndividualScopePermissions(
123                            long companyId, long groupId, String name, long primKey,
124                            long roleId, long actionIdsLong)
125                    throws PortalException, SystemException {
126    
127                    PermissionedModel permissionedModel = getPermissionedModel(
128                            name, primKey);
129    
130                    updateIndividualScopePermissions(
131                            companyId, groupId, name, permissionedModel, roleId, actionIdsLong,
132                            ResourceBlockConstants.OPERATOR_ADD);
133            }
134    
135            public void addIndividualScopePermissions(
136                            long companyId, long groupId, String name,
137                            PermissionedModel permissionedModel, long roleId,
138                            long actionIdsLong)
139                    throws SystemException {
140    
141                    updateIndividualScopePermissions(
142                            companyId, groupId, name, permissionedModel, roleId, actionIdsLong,
143                            ResourceBlockConstants.OPERATOR_ADD);
144            }
145    
146            /**
147             * Adds a resource block if necessary and associates the resource block
148             * permissions with it. The resource block will have an initial reference
149             * count of one.
150             *
151             * @param  companyId the primary key of the resource block's company
152             * @param  groupId the primary key of the resource block's group
153             * @return the new resource block
154             * @throws SystemException if a system exception occurred
155             */
156            public ResourceBlock addResourceBlock(
157                            long companyId, long groupId, String name, String permissionsHash,
158                            ResourceBlockPermissionsContainer resourceBlockPermissionsContainer)
159                    throws SystemException {
160    
161                    long resourceBlockId = counterLocalService.increment(
162                            ResourceBlock.class.getName());
163    
164                    ResourceBlock resourceBlock = resourceBlockPersistence.create(
165                            resourceBlockId);
166    
167                    resourceBlock.setCompanyId(companyId);
168                    resourceBlock.setGroupId(groupId);
169                    resourceBlock.setName(name);
170                    resourceBlock.setPermissionsHash(permissionsHash);
171                    resourceBlock.setReferenceCount(1);
172    
173                    updateResourceBlock(resourceBlock);
174    
175                    resourceBlockPermissionLocalService.addResourceBlockPermissions(
176                            resourceBlockId, resourceBlockPermissionsContainer);
177    
178                    return resourceBlock;
179            }
180    
181            @Override
182            public void deleteResourceBlock(long resourceBlockId)
183                    throws PortalException, SystemException {
184    
185                    ResourceBlock resourceBlock = resourceBlockPersistence.findByPrimaryKey(
186                            resourceBlockId);
187    
188                    deleteResourceBlock(resourceBlock);
189            }
190    
191            @Override
192            public void deleteResourceBlock(ResourceBlock resourceBlock)
193                    throws SystemException {
194    
195                    resourceBlockPermissionLocalService.deleteResourceBlockPermissions(
196                            resourceBlock.getPrimaryKey());
197    
198                    resourceBlockPersistence.remove(resourceBlock);
199            }
200    
201            public long getActionId(String name, String actionId)
202                    throws PortalException {
203    
204                    ResourceAction resourcAction =
205                            resourceActionLocalService.getResourceAction(name, actionId);
206    
207                    return resourcAction.getBitwiseValue();
208            }
209    
210            public long getActionIds(String name, List<String> actionIds)
211                    throws PortalException {
212    
213                    long actionIdsLong = 0;
214    
215                    for (String actionId : actionIds) {
216                            ResourceAction resourceAction =
217                                    resourceActionLocalService.getResourceAction(name, actionId);
218    
219                            actionIdsLong |= resourceAction.getBitwiseValue();
220                    }
221    
222                    return actionIdsLong;
223            }
224    
225            public List<String> getActionIds(String name, long actionIdsLong)
226                    throws SystemException {
227    
228                    List<ResourceAction> resourceActions =
229                            resourceActionLocalService.getResourceActions(name);
230    
231                    List<String> actionIds = new ArrayList<String>();
232    
233                    for (ResourceAction resourceAction : resourceActions) {
234                            if ((actionIdsLong & resourceAction.getBitwiseValue()) ==
235                                            resourceAction.getBitwiseValue()) {
236    
237                                    actionIds.add(resourceAction.getActionId());
238                            }
239                    }
240    
241                    return actionIds;
242            }
243    
244            public List<String> getCompanyScopePermissions(
245                            ResourceBlock resourceBlock, long roleId)
246                    throws SystemException {
247    
248                    long actionIdsLong =
249                            resourceTypePermissionLocalService.getCompanyScopeActionIds(
250                                    resourceBlock.getCompanyId(), resourceBlock.getName(), roleId);
251    
252                    return getActionIds(resourceBlock.getName(), actionIdsLong);
253            }
254    
255            public List<String> getGroupScopePermissions(
256                            ResourceBlock resourceBlock, long roleId)
257                    throws SystemException {
258    
259                    long actionIdsLong =
260                            resourceTypePermissionLocalService.getGroupScopeActionIds(
261                                    resourceBlock.getCompanyId(), resourceBlock.getGroupId(),
262                                    resourceBlock.getName(), roleId);
263    
264                    return getActionIds(resourceBlock.getName(), actionIdsLong);
265            }
266    
267            public PermissionedModel getPermissionedModel(String name, long primKey)
268                    throws PortalException, SystemException {
269    
270                    PersistedModelLocalService persistedModelLocalService =
271                            PersistedModelLocalServiceRegistryUtil.
272                                    getPersistedModelLocalService(name);
273    
274                    if (persistedModelLocalService == null) {
275                            throw new ResourceBlocksNotSupportedException();
276                    }
277    
278                    PersistedModel persistedModel =
279                            persistedModelLocalService.getPersistedModel(primKey);
280    
281                    try {
282                            return (PermissionedModel)persistedModel;
283                    }
284                    catch (ClassCastException cce) {
285                            throw new ResourceBlocksNotSupportedException();
286                    }
287            }
288    
289            public List<String> getPermissions(
290                            ResourceBlock resourceBlock, long roleId)
291                    throws SystemException {
292    
293                    ResourceBlockPermissionsContainer resourceBlockPermissionsContainer =
294                            resourceBlockPermissionLocalService.
295                                    getResourceBlockPermissionsContainer(
296                                            resourceBlock.getPrimaryKey());
297    
298                    long actionIdsLong = resourceBlockPermissionsContainer.getActionIds(
299                            roleId);
300    
301                    return getActionIds(resourceBlock.getName(), actionIdsLong);
302            }
303    
304            /**
305             * Returns the permissions hash of the resource permissions. The permissions
306             * hash is a representation of all the roles with access to the resource
307             * along with the actions they can perform.
308             *
309             * @param  resourceBlockPermissionsContainer the resource block permissions
310             * @return the permissions hash of the resource permissions
311             */
312            public String getPermissionsHash(
313                    ResourceBlockPermissionsContainer resourceBlockPermissionsContainer) {
314    
315                    SortedMap<Long, Long> permissions =
316                            resourceBlockPermissionsContainer.getPermissions();
317    
318                    // long is 8 bytes, there are 2 longs per permission, so preallocate
319                    // byte buffer to 16 * the number of permissions.
320    
321                    ByteBuffer byteBuffer = ByteBuffer.allocate(permissions.size() * 16);
322    
323                    for (Map.Entry<Long, Long> entry : permissions.entrySet()) {
324                            byteBuffer.putLong(entry.getKey());
325                            byteBuffer.putLong(entry.getValue());
326                    }
327    
328                    byteBuffer.flip();
329    
330                    return DigesterUtil.digestHex(Digester.SHA_1, byteBuffer);
331            }
332    
333            public ResourceBlock getResourceBlock(String name, long primKey)
334                    throws PortalException, SystemException {
335    
336                    PermissionedModel permissionedModel = getPermissionedModel(
337                            name, primKey);
338    
339                    return getResourceBlock(permissionedModel.getResourceBlockId());
340            }
341    
342            public List<Long> getResourceBlockIds(
343                            ResourceBlockIdsBag resourceBlockIdsBag, String name,
344                            String actionId)
345                    throws PortalException {
346    
347                    long actionIdsLong = getActionId(name, actionId);
348    
349                    return resourceBlockIdsBag.getResourceBlockIds(actionIdsLong);
350            }
351    
352            public ResourceBlockIdsBag getResourceBlockIdsBag(
353                            long companyId, long groupId, String name, long[] roleIds)
354                    throws SystemException {
355    
356                    return resourceBlockFinder.findByC_G_N_R(
357                            companyId, groupId, name, roleIds);
358            }
359    
360            public boolean hasPermission(
361                            String name, long primKey, String actionId,
362                            ResourceBlockIdsBag resourceBlockIdsBag)
363                    throws PortalException, SystemException {
364    
365                    PermissionedModel permissionedModel = getPermissionedModel(
366                            name, primKey);
367    
368                    return hasPermission(
369                            name, permissionedModel, actionId, resourceBlockIdsBag);
370            }
371    
372            public boolean hasPermission(
373                            String name, PermissionedModel permissionedModel, String actionId,
374                            ResourceBlockIdsBag resourceBlockIdsBag)
375                    throws PortalException {
376    
377                    long actionIdsLong = getActionId(name, actionId);
378    
379                    return resourceBlockIdsBag.hasResourceBlockId(
380                            permissionedModel.getResourceBlockId(), actionIdsLong);
381            }
382    
383            public boolean isSupported(String name) {
384                    return PersistedModelLocalServiceRegistryUtil.
385                            isPermissionedModelLocalService(name);
386            }
387    
388            public void releasePermissionedModelResourceBlock(
389                            PermissionedModel permissionedModel)
390                    throws PortalException, SystemException {
391    
392                    try {
393                            releaseResourceBlock(permissionedModel.getResourceBlockId());
394                    }
395                    catch (NoSuchResourceBlockException nsrbe) {
396                            if (_log.isWarnEnabled()) {
397                                    _log.warn(
398                                            "Resource block " + permissionedModel.getResourceBlockId() +
399                                                    " missing");
400                            }
401                    }
402            }
403    
404            public void releasePermissionedModelResourceBlock(String name, long primKey)
405                    throws PortalException, SystemException {
406    
407                    PermissionedModel permissionedModel = getPermissionedModel(
408                            name, primKey);
409    
410                    releasePermissionedModelResourceBlock(permissionedModel);
411            }
412    
413            /**
414             * Decrements the reference count of the resource block and updates it in
415             * the database or deletes the resource block if the reference count reaches
416             * zero.
417             *
418             * @param  resourceBlockId the primary key of the resource block
419             * @throws SystemException if a system exception occurred
420             */
421            public void releaseResourceBlock(long resourceBlockId)
422                    throws PortalException, SystemException {
423    
424                    ResourceBlock resourceBlock = getResourceBlock(resourceBlockId);
425    
426                    releaseResourceBlock(resourceBlock);
427            }
428    
429            /**
430             * Decrements the reference count of the resource block and updates it in
431             * the database or deletes the resource block if the reference count reaches
432             * zero.
433             *
434             * @param  resourceBlock the resource block
435             * @throws SystemException if a system exception occurred
436             */
437            public void releaseResourceBlock(ResourceBlock resourceBlock)
438                    throws SystemException {
439    
440                    long referenceCount = resourceBlock.getReferenceCount() - 1;
441    
442                    if (referenceCount <= 0) {
443                            deleteResourceBlock(resourceBlock);
444                            return;
445                    }
446    
447                    resourceBlock.setReferenceCount(referenceCount);
448    
449                    updateResourceBlock(resourceBlock);
450            }
451    
452            public void removeAllGroupScopePermissions(
453                            long companyId, String name, long roleId, long actionIdsLong)
454                    throws SystemException {
455    
456                    List<ResourceTypePermission> resourceTypePermissions =
457                            resourceTypePermissionLocalService.
458                                    getGroupScopeResourceTypePermissions(companyId, name, roleId);
459    
460                    for (ResourceTypePermission resourceTypePermission :
461                                    resourceTypePermissions) {
462    
463                            removeGroupScopePermissions(
464                                    companyId, resourceTypePermission.getGroupId(), name, roleId,
465                                    actionIdsLong);
466                    }
467            }
468    
469            public void removeAllGroupScopePermissions(
470                            long companyId, String name, long roleId, String actionId)
471                    throws PortalException, SystemException {
472    
473                    removeAllGroupScopePermissions(
474                            companyId, name, roleId, getActionId(name, actionId));
475            }
476    
477            public void removeCompanyScopePermission(
478                            long companyId, String name, long roleId, String actionId)
479                    throws PortalException, SystemException {
480    
481                    updateCompanyScopePermissions(
482                            companyId, name, roleId, getActionId(name, actionId),
483                            ResourceBlockConstants.OPERATOR_REMOVE);
484            }
485    
486            public void removeCompanyScopePermissions(
487                            long companyId, String name, long roleId, long actionIdsLong)
488                    throws SystemException {
489    
490                    updateCompanyScopePermissions(
491                            companyId, name, roleId, actionIdsLong,
492                            ResourceBlockConstants.OPERATOR_REMOVE);
493            }
494    
495            public void removeGroupScopePermission(
496                            long companyId, long groupId, String name, long roleId,
497                            String actionId)
498                    throws PortalException, SystemException {
499    
500                    updateGroupScopePermissions(
501                            companyId, groupId, name, roleId, getActionId(name, actionId),
502                            ResourceBlockConstants.OPERATOR_REMOVE);
503            }
504    
505            public void removeGroupScopePermissions(
506                            long companyId, long groupId, String name, long roleId,
507                            long actionIdsLong)
508                    throws SystemException {
509    
510                    updateGroupScopePermissions(
511                            companyId, groupId, name, roleId, actionIdsLong,
512                            ResourceBlockConstants.OPERATOR_REMOVE);
513            }
514    
515            public void removeIndividualScopePermission(
516                            long companyId, long groupId, String name, long primKey,
517                            long roleId, String actionId)
518                    throws PortalException, SystemException {
519    
520                    PermissionedModel permissionedModel = getPermissionedModel(
521                            name, primKey);
522    
523                    updateIndividualScopePermissions(
524                            companyId, groupId, name, permissionedModel, roleId,
525                            getActionId(name, actionId),
526                            ResourceBlockConstants.OPERATOR_REMOVE);
527            }
528    
529            public void removeIndividualScopePermission(
530                            long companyId, long groupId, String name,
531                            PermissionedModel permissionedModel, long roleId, String actionId)
532                    throws PortalException, SystemException {
533    
534                    updateIndividualScopePermissions(
535                            companyId, groupId, name, permissionedModel, roleId,
536                            getActionId(name, actionId),
537                            ResourceBlockConstants.OPERATOR_REMOVE);
538            }
539    
540            public void removeIndividualScopePermissions(
541                            long companyId, long groupId, String name, long primKey,
542                            long roleId, long actionIdsLong)
543                    throws PortalException, SystemException {
544    
545                    PermissionedModel permissionedModel = getPermissionedModel(
546                            name, primKey);
547    
548                    updateIndividualScopePermissions(
549                            companyId, groupId, name, permissionedModel, roleId, actionIdsLong,
550                            ResourceBlockConstants.OPERATOR_REMOVE);
551            }
552    
553            public void removeIndividualScopePermissions(
554                            long companyId, long groupId, String name,
555                            PermissionedModel permissionedModel, long roleId,
556                            long actionIdsLong)
557                    throws SystemException {
558    
559                    updateIndividualScopePermissions(
560                            companyId, groupId, name, permissionedModel, roleId, actionIdsLong,
561                            ResourceBlockConstants.OPERATOR_REMOVE);
562            }
563    
564            /**
565             * Increments the reference count of the resource block and updates it in
566             * the database.
567             *
568             * @param  resourceBlockId the primary key of the resource block
569             * @throws SystemException if a system exception occurred
570             */
571            public void retainResourceBlock(long resourceBlockId)
572                    throws PortalException, SystemException {
573    
574                    ResourceBlock resourceBlock = getResourceBlock(resourceBlockId);
575    
576                    retainResourceBlock(resourceBlock);
577            }
578    
579            /**
580             * Increments the reference count of the resource block and updates it in
581             * the database.
582             *
583             * @param  resourceBlock the resource block
584             * @throws SystemException if a system exception occurred
585             */
586            public void retainResourceBlock(ResourceBlock resourceBlock)
587                    throws SystemException {
588    
589                    resourceBlock.setReferenceCount(resourceBlock.getReferenceCount() + 1);
590    
591                    updateResourceBlock(resourceBlock);
592            }
593    
594            public void setCompanyScopePermissions(
595                            long companyId, String name, long roleId, List<String> actionIds)
596                    throws PortalException, SystemException {
597    
598                    updateCompanyScopePermissions(
599                            companyId, name, roleId, getActionIds(name, actionIds),
600                            ResourceBlockConstants.OPERATOR_SET);
601            }
602    
603            public void setCompanyScopePermissions(
604                            long companyId, String name, long roleId, long actionIdsLong)
605                    throws SystemException {
606    
607                    updateCompanyScopePermissions(
608                            companyId, name, roleId, actionIdsLong,
609                            ResourceBlockConstants.OPERATOR_SET);
610            }
611    
612            public void setGroupScopePermissions(
613                            long companyId, long groupId, String name, long roleId,
614                            List<String> actionIds)
615                    throws PortalException, SystemException {
616    
617                    updateGroupScopePermissions(
618                            companyId, groupId, name, roleId,
619                            getActionIds(name, actionIds), ResourceBlockConstants.OPERATOR_SET);
620            }
621    
622            public void setGroupScopePermissions(
623                            long companyId, long groupId, String name, long roleId,
624                            long actionIdsLong)
625                    throws SystemException {
626    
627                    updateGroupScopePermissions(
628                            companyId, groupId, name, roleId, actionIdsLong,
629                            ResourceBlockConstants.OPERATOR_SET);
630            }
631    
632            public void setIndividualScopePermissions(
633                            long companyId, long groupId, String name, long primKey,
634                            long roleId, List<String> actionIds)
635                    throws PortalException, SystemException {
636    
637                    PermissionedModel permissionedModel = getPermissionedModel(
638                            name, primKey);
639    
640                    updateIndividualScopePermissions(
641                            companyId, groupId, name, permissionedModel, roleId,
642                            getActionIds(name, actionIds), ResourceBlockConstants.OPERATOR_SET);
643            }
644    
645            public void setIndividualScopePermissions(
646                            long companyId, long groupId, String name, long primKey,
647                            long roleId, long actionIdsLong)
648                    throws PortalException, SystemException {
649    
650                    PermissionedModel permissionedModel = getPermissionedModel(
651                            name, primKey);
652    
653                    updateIndividualScopePermissions(
654                            companyId, groupId, name, permissionedModel, roleId, actionIdsLong,
655                            ResourceBlockConstants.OPERATOR_SET);
656            }
657    
658            public void setIndividualScopePermissions(
659                            long companyId, long groupId, String name, long primKey,
660                            Map<Long, String[]> roleIdsToActionIds)
661                    throws PortalException, SystemException {
662    
663                    boolean flushEnabled = PermissionThreadLocal.isFlushEnabled();
664    
665                    PermissionThreadLocal.setIndexEnabled(false);
666    
667                    try {
668                            PermissionedModel permissionedModel = getPermissionedModel(
669                                    name, primKey);
670    
671                            for (Map.Entry<Long, String[]> entry :
672                                            roleIdsToActionIds.entrySet()) {
673    
674                                    long roleId = entry.getKey();
675                                    String[] actionIds = entry.getValue();
676    
677                                    updateIndividualScopePermissions(
678                                            companyId, groupId, name, permissionedModel, roleId,
679                                            getActionIds(name, ListUtil.fromArray(actionIds)),
680                                            ResourceBlockConstants.OPERATOR_SET);
681                            }
682                    }
683                    finally {
684                            PermissionThreadLocal.setIndexEnabled(flushEnabled);
685    
686                            PermissionCacheUtil.clearCache();
687                    }
688            }
689    
690            public void setIndividualScopePermissions(
691                            long companyId, long groupId, String name,
692                            PermissionedModel permissionedModel, long roleId,
693                            List<String> actionIds)
694                    throws PortalException, SystemException {
695    
696                    updateIndividualScopePermissions(
697                            companyId, groupId, name, permissionedModel, roleId,
698                            getActionIds(name, actionIds), ResourceBlockConstants.OPERATOR_SET);
699            }
700    
701            public void setIndividualScopePermissions(
702                            long companyId, long groupId, String name,
703                            PermissionedModel permissionedModel, long roleId,
704                            long actionIdsLong)
705                    throws SystemException {
706    
707                    updateIndividualScopePermissions(
708                            companyId, groupId, name, permissionedModel, roleId, actionIdsLong,
709                            ResourceBlockConstants.OPERATOR_SET);
710            }
711    
712            public void updateCompanyScopePermissions(
713                            long companyId, String name, long roleId,
714                            long actionIdsLong, int operator)
715                    throws SystemException {
716    
717                    resourceTypePermissionLocalService.
718                            updateCompanyScopeResourceTypePermissions(
719                                    companyId, name, roleId, actionIdsLong, operator);
720    
721                    List<ResourceBlock> resourceBlocks =
722                            resourceBlockPersistence.findByC_N(companyId, name);
723    
724                    updatePermissions(resourceBlocks, roleId, actionIdsLong, operator);
725    
726                    PermissionCacheUtil.clearCache();
727            }
728    
729            public void updateGroupScopePermissions(
730                            long companyId, long groupId, String name, long roleId,
731                            long actionIdsLong, int operator)
732                    throws SystemException {
733    
734                    resourceTypePermissionLocalService.
735                            updateGroupScopeResourceTypePermissions(
736                                    companyId, groupId, name, roleId, actionIdsLong, operator);
737    
738                    List<ResourceBlock> resourceBlocks =
739                            resourceBlockPersistence.findByC_G_N(companyId, groupId, name);
740    
741                    updatePermissions(resourceBlocks, roleId, actionIdsLong, operator);
742    
743                    PermissionCacheUtil.clearCache();
744            }
745    
746            public void updateIndividualScopePermissions(
747                            long companyId, long groupId, String name,
748                            PermissionedModel permissionedModel, long roleId,
749                            long actionIdsLong, int operator)
750                    throws SystemException {
751    
752                    ResourceBlock resourceBlock =
753                            resourceBlockPersistence.fetchByPrimaryKey(
754                                    permissionedModel.getResourceBlockId());
755    
756                    ResourceBlockPermissionsContainer resourceBlockPermissionsContainer =
757                            null;
758    
759                    if (resourceBlock == null) {
760                            resourceBlockPermissionsContainer =
761                                    resourceTypePermissionLocalService.
762                                            getResourceBlockPermissionsContainer(
763                                                    companyId, groupId, name);
764                    }
765                    else {
766                            resourceBlockPermissionsContainer =
767                                    resourceBlockPermissionLocalService.
768                                            getResourceBlockPermissionsContainer(
769                                                    resourceBlock.getPrimaryKey());
770                    }
771    
772                    long oldActionIdsLong = resourceBlockPermissionsContainer.getActionIds(
773                            roleId);
774    
775                    if (operator == ResourceBlockConstants.OPERATOR_ADD) {
776                            actionIdsLong |= oldActionIdsLong;
777                    }
778                    else if (operator == ResourceBlockConstants.OPERATOR_REMOVE) {
779                            actionIdsLong = oldActionIdsLong & (~actionIdsLong);
780                    }
781    
782                    if (resourceBlock != null) {
783                            if (oldActionIdsLong == actionIdsLong) {
784                                    return;
785                            }
786    
787                            releaseResourceBlock(resourceBlock);
788                    }
789    
790                    resourceBlockPermissionsContainer.setPermissions(roleId, actionIdsLong);
791    
792                    String permissionsHash = getPermissionsHash(
793                            resourceBlockPermissionsContainer);
794    
795                    updateResourceBlockId(
796                            companyId, groupId, name, permissionedModel, permissionsHash,
797                            resourceBlockPermissionsContainer);
798    
799                    PermissionCacheUtil.clearCache();
800            }
801    
802            public ResourceBlock updateResourceBlockId(
803                            long companyId, long groupId, String name,
804                            PermissionedModel permissionedModel, String permissionsHash,
805                            ResourceBlockPermissionsContainer resourceBlockPermissionsContainer)
806                    throws SystemException {
807    
808                    ResourceBlock resourceBlock = resourceBlockPersistence.fetchByC_G_N_P(
809                            companyId, groupId, name, permissionsHash);
810    
811                    if (resourceBlock == null) {
812                            resourceBlock = addResourceBlock(
813                                    companyId, groupId, name, permissionsHash,
814                                    resourceBlockPermissionsContainer);
815                    }
816                    else {
817                            retainResourceBlock(resourceBlock);
818                    }
819    
820                    permissionedModel.setResourceBlockId(
821                            resourceBlock.getResourceBlockId());
822    
823                    permissionedModel.persist();
824    
825                    return resourceBlock;
826            }
827    
828            public void verifyResourceBlockId(
829                            long companyId, String name, long primKey)
830                    throws PortalException, SystemException {
831    
832                    PermissionedModel permissionedModel = getPermissionedModel(
833                            name, primKey);
834    
835                    ResourceBlock resourceBlock =
836                                    resourceBlockPersistence.fetchByPrimaryKey(
837                            permissionedModel.getResourceBlockId());
838    
839                    if (resourceBlock == null) {
840                            if (_log.isWarnEnabled()) {
841                                    _log.warn(
842                                            "Resource block " + permissionedModel.getResourceBlockId() +
843                                                    " missing for " + name + "#" + primKey);
844                            }
845    
846                            long groupId = 0;
847                            long ownerId = 0;
848    
849                            if (permissionedModel instanceof GroupedModel) {
850                                    GroupedModel groupedModel = (GroupedModel)permissionedModel;
851    
852                                    groupId = groupedModel.getGroupId();
853                                    ownerId = groupedModel.getUserId();
854                            }
855                            else if (permissionedModel instanceof AuditedModel) {
856                                    AuditedModel auditedModel = (AuditedModel)permissionedModel;
857    
858                                    ownerId = auditedModel.getUserId();
859                            }
860    
861                            resourceLocalService.addResources(
862                                    companyId, groupId, ownerId, name, primKey, false, true, true);
863                    }
864            }
865    
866            protected void updatePermissions(
867                            List<ResourceBlock> resourceBlocks, long roleId, long actionIdsLong,
868                            int operator)
869                    throws SystemException {
870    
871                    for (ResourceBlock resourceBlock : resourceBlocks) {
872                            resourceBlockPermissionLocalService.updateResourceBlockPermission(
873                                    resourceBlock.getPrimaryKey(), roleId, actionIdsLong, operator);
874    
875                            updatePermissionsHash(resourceBlock);
876                    }
877            }
878    
879            protected void updatePermissionsHash(ResourceBlock resourceBlock)
880                    throws SystemException {
881    
882                    ResourceBlockPermissionsContainer resourceBlockPermissionsContainer =
883                            resourceBlockPermissionLocalService.
884                            getResourceBlockPermissionsContainer(resourceBlock.getPrimaryKey());
885    
886                    String permissionsHash = getPermissionsHash(
887                            resourceBlockPermissionsContainer);
888    
889                    resourceBlock.setPermissionsHash(permissionsHash);
890    
891                    updateResourceBlock(resourceBlock);
892            }
893    
894    }