001    /**
002     * Copyright (c) 2000-2012 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.kernel.exception.PortalException;
018    import com.liferay.portal.kernel.exception.SystemException;
019    import com.liferay.portal.model.ResourceBlock;
020    import com.liferay.portal.model.ResourceBlockConstants;
021    import com.liferay.portal.model.ResourceBlockPermission;
022    import com.liferay.portal.model.ResourceBlockPermissionsContainer;
023    import com.liferay.portal.service.base.ResourceBlockPermissionLocalServiceBaseImpl;
024    
025    import java.util.HashMap;
026    import java.util.HashSet;
027    import java.util.List;
028    import java.util.Map;
029    import java.util.Set;
030    
031    /**
032     * Manages resource block permissions.
033     *
034     * <p>
035     * Never directly access this service, always go through the resource block
036     * local service.
037     * </p>
038     *
039     * @author Connor McKay
040     */
041    public class ResourceBlockPermissionLocalServiceImpl
042            extends ResourceBlockPermissionLocalServiceBaseImpl {
043    
044            public void addResourceBlockPermissions(
045                            long resourceBlockId,
046                            ResourceBlockPermissionsContainer resourceBlockPermissionsContainer)
047                    throws SystemException {
048    
049                    Map<Long, Long> permissions =
050                            resourceBlockPermissionsContainer.getPermissions();
051    
052                    for (Map.Entry<Long, Long> permission : permissions.entrySet()) {
053                            long resourceBlockPermissionId = counterLocalService.increment();
054    
055                            ResourceBlockPermission resourceBlockPermission =
056                                    resourceBlockPermissionPersistence.create(
057                                            resourceBlockPermissionId);
058    
059                            resourceBlockPermission.setResourceBlockId(resourceBlockId);
060                            resourceBlockPermission.setRoleId(permission.getKey());
061                            resourceBlockPermission.setActionIds(permission.getValue());
062    
063                            updateResourceBlockPermission(resourceBlockPermission);
064                    }
065            }
066    
067            public void deleteResourceBlockPermissions(long resourceBlockId)
068                    throws SystemException {
069    
070                    resourceBlockPermissionPersistence.removeByResourceBlockId(
071                            resourceBlockId);
072            }
073    
074            public Map<Long, Set<String>> getAvailableResourceBlockPermissionActionIds(
075                            long[] roleIds, String name, long primKey, List<String> actionIds)
076                    throws PortalException, SystemException {
077    
078                    ResourceBlock resourceBlock =
079                            resourceBlockLocalService.getResourceBlock(name, primKey);
080    
081                    Map<Long, Set<String>> roleIdsToActionIds =
082                            new HashMap<Long, Set<String>>();
083    
084                    for (long roleId : roleIds) {
085                            Set<String> availableActionIds = roleIdsToActionIds.get(roleId);
086    
087                            if (availableActionIds != null) {
088                                    continue;
089                            }
090    
091                            List<String> resourceBlockActionIds =
092                                    resourceBlockLocalService.getPermissions(resourceBlock, roleId);
093    
094                            if (resourceBlockActionIds.isEmpty()) {
095                                    continue;
096                            }
097    
098                            availableActionIds = new HashSet<String>();
099    
100                            roleIdsToActionIds.put(roleId, availableActionIds);
101    
102                            for (String actionId : actionIds) {
103                                    if (resourceBlockActionIds.contains(actionId)) {
104                                            availableActionIds.add(actionId);
105                                    }
106                            }
107                    }
108    
109                    return roleIdsToActionIds;
110            }
111    
112            public ResourceBlockPermissionsContainer
113                            getResourceBlockPermissionsContainer(long resourceBlockId)
114                    throws SystemException {
115    
116                    List<ResourceBlockPermission> resourceBlockPermissions =
117                            resourceBlockPermissionPersistence.findByResourceBlockId(
118                                    resourceBlockId);
119    
120                    ResourceBlockPermissionsContainer resourceBlockPermissionContainer =
121                            new ResourceBlockPermissionsContainer();
122    
123                    for (ResourceBlockPermission resourceBlockPermission :
124                                    resourceBlockPermissions) {
125    
126                            resourceBlockPermissionContainer.setPermissions(
127                                    resourceBlockPermission.getRoleId(),
128                                    resourceBlockPermission.getActionIds());
129                    }
130    
131                    return resourceBlockPermissionContainer;
132            }
133    
134            public void updateResourceBlockPermission(
135                            long resourceBlockId, long roleId, long actionIdsLong, int operator)
136                    throws SystemException {
137    
138                    ResourceBlockPermission resourceBlockPermission =
139                            resourceBlockPermissionPersistence.fetchByR_R(
140                                    resourceBlockId, roleId);
141    
142                    if (resourceBlockPermission == null) {
143                            if (actionIdsLong == 0) {
144                                    return;
145                            }
146    
147                            long resourceBlockPermissionId = counterLocalService.increment();
148    
149                            resourceBlockPermission = resourceBlockPermissionPersistence.create(
150                                    resourceBlockPermissionId);
151    
152                            resourceBlockPermission.setResourceBlockId(resourceBlockId);
153                            resourceBlockPermission.setRoleId(roleId);
154                    }
155    
156                    if (operator == ResourceBlockConstants.OPERATOR_ADD) {
157                            actionIdsLong |= resourceBlockPermission.getActionIds();
158                    }
159                    else if (operator == ResourceBlockConstants.OPERATOR_REMOVE) {
160                            actionIdsLong =
161                                    resourceBlockPermission.getActionIds() & (~actionIdsLong);
162                    }
163    
164                    if (actionIdsLong == 0) {
165                            deleteResourceBlockPermission(resourceBlockPermission);
166                    }
167                    else {
168                            resourceBlockPermission.setActionIds(actionIdsLong);
169    
170                            updateResourceBlockPermission(resourceBlockPermission);
171                    }
172            }
173    
174    }