001/**
002 * Copyright 2005-2016 The Kuali Foundation
003 *
004 * Licensed under the Educational Community License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.opensource.org/licenses/ecl2.php
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016package org.kuali.rice.kim.api.cache;
017
018import org.apache.commons.collections.CollectionUtils;
019import org.apache.commons.lang.StringUtils;
020import org.kuali.rice.kim.api.permission.Permission;
021import org.kuali.rice.kim.api.permission.PermissionService;
022import org.kuali.rice.kim.api.responsibility.Responsibility;
023import org.kuali.rice.kim.api.responsibility.ResponsibilityService;
024import org.kuali.rice.kim.api.role.RoleService;
025import org.kuali.rice.kim.api.services.KimApiServiceLocator;
026
027import java.util.ArrayList;
028import java.util.Collections;
029import java.util.List;
030
031
032public final class KimCacheUtils {
033
034    private KimCacheUtils() {
035        throw new UnsupportedOperationException();
036    }
037
038    /**
039     * Used for a caching condition to determine if a role passed to a method is derived or not.
040     *
041     * @param roleIds list of role id values
042     *
043     * @return true if list contains a derived role.
044     */
045    public static boolean isDynamicRoleMembership(List<String> roleIds) {
046        if (CollectionUtils.isEmpty(roleIds)) {
047            return false;
048        }
049        RoleService roleService = KimApiServiceLocator.getRoleService();
050        for (String roleId : roleIds) {
051             if (roleService.isDynamicRoleMembership(roleId)) {
052                 return true;
053             }
054        }
055        return false;
056    }
057
058    /**
059     * Used for a caching condition to determine if a role passed to a method is derived or not.
060     *
061     * @param namespaceCode namespaceCode of role
062     * @param roleName name of role
063     *
064     * @return true if list contains role.
065     */
066    public static boolean isDynamicMembshipRoleByNamespaceAndName(String namespaceCode, String roleName) {
067        List<String> roleIds = Collections.singletonList(
068                KimApiServiceLocator.getRoleService().getRoleIdByNamespaceCodeAndName(namespaceCode, roleName));
069        return isDynamicRoleMembership(roleIds);
070    }
071
072    /**
073     * Used for a caching condition to determine if a responsibility is assigned to a derived role.
074     *
075     * @param responsibilityId id of responsibility
076     *
077     * @return true if assigned to a derived role.
078     */
079    public static boolean isResponsibilityIdAssignedToDynamicRole(String responsibilityId) {
080        if ( StringUtils.isBlank(responsibilityId)) {
081            return false;
082        }
083
084        List<String> roleIds = KimApiServiceLocator.getResponsibilityService().getRoleIdsForResponsibility(responsibilityId);
085        return isDynamicRoleMembership(roleIds);
086    }
087
088    /**
089     * Used for a caching condition to determine if a responsibility is assigned to a derived role.
090     *
091     * @param namespaceCode namespaceCode of responsibility
092     * @param responsibilityName name of responsibility
093     *
094     * @return true if assigned to a derived role.
095     */
096    public static boolean isResponsibilityAssignedToDynamicRole(String namespaceCode, String responsibilityName) {
097        if (StringUtils.isBlank(namespaceCode) || StringUtils.isBlank(responsibilityName)) {
098            return false;
099        }
100        Responsibility responsibility = KimApiServiceLocator.getResponsibilityService().findRespByNamespaceCodeAndName(namespaceCode, responsibilityName);
101
102        if (responsibility != null) {
103            return isResponsibilityIdAssignedToDynamicRole(responsibility.getId());
104        }
105        return false;
106    }
107
108    /**
109     * Used for a caching condition to determine if a responsibility template is assigned to a derived role.
110     *
111     * @param namespaceCode namespaceCode of permission
112     * @param responsibilityTemplateName name of responsibility template
113     *
114     * @return true if assigned to a derived role.
115     */
116    public static boolean isResponsibilityTemplateAssignedToDynamicRole(String namespaceCode,
117            String responsibilityTemplateName) {
118        if (StringUtils.isBlank(namespaceCode) || StringUtils.isBlank(responsibilityTemplateName)) {
119            return false;
120        }
121        ResponsibilityService respService = KimApiServiceLocator.getResponsibilityService();
122        List<Responsibility> responsibilities = KimApiServiceLocator.getResponsibilityService().findResponsibilitiesByTemplate(namespaceCode, responsibilityTemplateName);
123        List<String> roleIds = new ArrayList<String>();
124        for (Responsibility resp : responsibilities) {
125            roleIds.addAll(respService.getRoleIdsForResponsibility(resp.getId()));
126        }
127
128        return isDynamicRoleMembership(roleIds);
129    }
130
131}