001    /**
002     * Copyright (c) 2000-present 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.model.ResourceBlock;
019    import com.liferay.portal.model.ResourceBlockConstants;
020    import com.liferay.portal.model.ResourceBlockPermission;
021    import com.liferay.portal.model.ResourceBlockPermissionsContainer;
022    import com.liferay.portal.service.base.ResourceBlockPermissionLocalServiceBaseImpl;
023    
024    import java.util.Collections;
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            @Override
045            public void addResourceBlockPermissions(
046                    long resourceBlockId,
047                    ResourceBlockPermissionsContainer resourceBlockPermissionsContainer) {
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            @Override
068            public void deleteResourceBlockPermissions(long resourceBlockId) {
069                    resourceBlockPermissionPersistence.removeByResourceBlockId(
070                            resourceBlockId);
071            }
072    
073            /**
074             * @deprecated As of 7.0.0, replaced by {@link
075             *             #getAvailableResourceBlockPermissionActionIds(String, long,
076             *             List)}
077             */
078            @Deprecated
079            @Override
080            public Map<Long, Set<String>> getAvailableResourceBlockPermissionActionIds(
081                            long[] roleIds, String name, long primKey, List<String> actionIds)
082                    throws PortalException {
083    
084                    return getAvailableResourceBlockPermissionActionIds(
085                            name, primKey, actionIds);
086            }
087    
088            @Override
089            public Map<Long, Set<String>> getAvailableResourceBlockPermissionActionIds(
090                            String name, long primKey, List<String> actionIds)
091                    throws PortalException {
092    
093                    if (actionIds.isEmpty()) {
094                            return Collections.emptyMap();
095                    }
096    
097                    ResourceBlock resourceBlock =
098                            resourceBlockLocalService.getResourceBlock(name, primKey);
099    
100                    List<ResourceBlockPermission> resourceBlockPermissions =
101                            resourceBlockPermissionPersistence.findByResourceBlockId(
102                                    resourceBlock.getResourceBlockId());
103    
104                    Map<Long, Set<String>> roleIdsToActionIds = new HashMap<>();
105    
106                    for (ResourceBlockPermission resourceBlockPermission :
107                                    resourceBlockPermissions) {
108    
109                            Set<String> availableActionIds = new HashSet<>();
110    
111                            List<String> resourceBlockActionIds =
112                                    resourceBlockLocalService.getActionIds(
113                                            name, resourceBlockPermission.getActionIds());
114    
115                            for (String actionId : actionIds) {
116                                    if (resourceBlockActionIds.contains(actionId)) {
117                                            availableActionIds.add(actionId);
118                                    }
119                            }
120    
121                            if (!availableActionIds.isEmpty()) {
122                                    roleIdsToActionIds.put(
123                                            resourceBlockPermission.getRoleId(), availableActionIds);
124                            }
125                    }
126    
127                    return roleIdsToActionIds;
128            }
129    
130            @Override
131            public ResourceBlockPermissionsContainer
132                    getResourceBlockPermissionsContainer(long resourceBlockId) {
133    
134                    List<ResourceBlockPermission> resourceBlockPermissions =
135                            resourceBlockPermissionPersistence.findByResourceBlockId(
136                                    resourceBlockId);
137    
138                    ResourceBlockPermissionsContainer resourceBlockPermissionContainer =
139                            new ResourceBlockPermissionsContainer();
140    
141                    for (ResourceBlockPermission resourceBlockPermission :
142                                    resourceBlockPermissions) {
143    
144                            resourceBlockPermissionContainer.setPermissions(
145                                    resourceBlockPermission.getRoleId(),
146                                    resourceBlockPermission.getActionIds());
147                    }
148    
149                    return resourceBlockPermissionContainer;
150            }
151    
152            @Override
153            public int getResourceBlockPermissionsCount(
154                    long resourceBlockId, long roleId) {
155    
156                    return resourceBlockPermissionPersistence.countByR_R(
157                            resourceBlockId, roleId);
158            }
159    
160            @Override
161            public void updateResourceBlockPermission(
162                    long resourceBlockId, long roleId, long actionIdsLong, int operator) {
163    
164                    ResourceBlockPermission resourceBlockPermission =
165                            resourceBlockPermissionPersistence.fetchByR_R(
166                                    resourceBlockId, roleId);
167    
168                    if (resourceBlockPermission == null) {
169                            if (actionIdsLong == 0) {
170                                    return;
171                            }
172    
173                            long resourceBlockPermissionId = counterLocalService.increment();
174    
175                            resourceBlockPermission = resourceBlockPermissionPersistence.create(
176                                    resourceBlockPermissionId);
177    
178                            resourceBlockPermission.setResourceBlockId(resourceBlockId);
179                            resourceBlockPermission.setRoleId(roleId);
180                    }
181    
182                    if (operator == ResourceBlockConstants.OPERATOR_ADD) {
183                            actionIdsLong |= resourceBlockPermission.getActionIds();
184                    }
185                    else if (operator == ResourceBlockConstants.OPERATOR_REMOVE) {
186                            actionIdsLong =
187                                    resourceBlockPermission.getActionIds() & (~actionIdsLong);
188                    }
189    
190                    if (actionIdsLong == 0) {
191                            deleteResourceBlockPermission(resourceBlockPermission);
192                    }
193                    else {
194                            resourceBlockPermission.setActionIds(actionIdsLong);
195    
196                            updateResourceBlockPermission(resourceBlockPermission);
197                    }
198            }
199    
200    }