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