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.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 int getResourceBlockPermissionsCount(
135                            long resourceBlockId, long roleId)
136                    throws SystemException {
137    
138                    return resourceBlockPermissionPersistence.countByR_R(
139                            resourceBlockId, roleId);
140            }
141    
142            public void updateResourceBlockPermission(
143                            long resourceBlockId, long roleId, long actionIdsLong, int operator)
144                    throws SystemException {
145    
146                    ResourceBlockPermission resourceBlockPermission =
147                            resourceBlockPermissionPersistence.fetchByR_R(
148                                    resourceBlockId, roleId);
149    
150                    if (resourceBlockPermission == null) {
151                            if (actionIdsLong == 0) {
152                                    return;
153                            }
154    
155                            long resourceBlockPermissionId = counterLocalService.increment();
156    
157                            resourceBlockPermission = resourceBlockPermissionPersistence.create(
158                                    resourceBlockPermissionId);
159    
160                            resourceBlockPermission.setResourceBlockId(resourceBlockId);
161                            resourceBlockPermission.setRoleId(roleId);
162                    }
163    
164                    if (operator == ResourceBlockConstants.OPERATOR_ADD) {
165                            actionIdsLong |= resourceBlockPermission.getActionIds();
166                    }
167                    else if (operator == ResourceBlockConstants.OPERATOR_REMOVE) {
168                            actionIdsLong =
169                                    resourceBlockPermission.getActionIds() & (~actionIdsLong);
170                    }
171    
172                    if (actionIdsLong == 0) {
173                            deleteResourceBlockPermission(resourceBlockPermission);
174                    }
175                    else {
176                            resourceBlockPermission.setActionIds(actionIdsLong);
177    
178                            updateResourceBlockPermission(resourceBlockPermission);
179                    }
180            }
181    
182    }