001    /**
002     * Copyright 2005-2014 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     */
016    package org.kuali.rice.kim.api.cache;
017    
018    import org.apache.commons.collections.CollectionUtils;
019    import org.apache.commons.lang.StringUtils;
020    import org.kuali.rice.kim.api.permission.Permission;
021    import org.kuali.rice.kim.api.permission.PermissionService;
022    import org.kuali.rice.kim.api.responsibility.Responsibility;
023    import org.kuali.rice.kim.api.responsibility.ResponsibilityService;
024    import org.kuali.rice.kim.api.role.RoleService;
025    import org.kuali.rice.kim.api.services.KimApiServiceLocator;
026    
027    import java.util.ArrayList;
028    import java.util.Collections;
029    import java.util.List;
030    
031    
032    public 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    }