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.service.impl; 017 018 import java.sql.Timestamp; 019 import java.util.ArrayList; 020 import java.util.HashMap; 021 import java.util.List; 022 import java.util.Map; 023 024 import org.apache.commons.lang.StringUtils; 025 import org.joda.time.DateTime; 026 import org.kuali.rice.core.api.criteria.CriteriaValue; 027 import org.kuali.rice.core.api.criteria.EqualPredicate; 028 import org.kuali.rice.core.api.criteria.Predicate; 029 import org.kuali.rice.core.api.criteria.QueryByCriteria; 030 import org.kuali.rice.core.api.exception.RiceIllegalArgumentException; 031 import org.kuali.rice.kim.api.identity.IdentityService; 032 import org.kuali.rice.kim.api.identity.entity.Entity; 033 import org.kuali.rice.kim.api.identity.entity.EntityDefault; 034 import org.kuali.rice.kim.api.identity.entity.EntityDefaultQueryResults; 035 import org.kuali.rice.kim.api.identity.principal.Principal; 036 import org.kuali.rice.kim.api.identity.privacy.EntityPrivacyPreferences; 037 import org.kuali.rice.kim.dao.LdapPrincipalDao; 038 import org.kuali.rice.kim.impl.identity.IdentityServiceImpl; 039 import org.kuali.rice.kim.impl.identity.entity.EntityBo; 040 041 import javax.jws.WebParam; 042 043 /** 044 * Implementation of {@link IdentityService} that communicates with and serves information 045 * from the UA Enterprise Directory Service. 046 * 047 * 048 * @author Kuali Rice Team (rice.collab@kuali.org) 049 */ 050 public class LdapIdentityDelegateServiceImpl extends IdentityServiceImpl { 051 private LdapPrincipalDao principalDao; 052 053 @Override 054 public Entity getEntity(String entityId) { 055 if (StringUtils.isBlank(entityId)) { 056 throw new RiceIllegalArgumentException("entityId is blank"); 057 } 058 059 Entity edsInfo = getPrincipalDao().getEntity(entityId); 060 if (edsInfo != null) { 061 return edsInfo; 062 } else { 063 return super.getEntity(entityId); 064 } 065 } 066 067 /** 068 * Overridden to populate this information from the LdapPrincipalDao 069 */ 070 @Override 071 public Entity getEntityByPrincipalId(String principalId) { 072 if (StringUtils.isBlank(principalId)) { 073 throw new RiceIllegalArgumentException("principalId is blank"); 074 } 075 076 Entity edsInfo = getPrincipalDao().getEntityByPrincipalId(principalId); 077 if (edsInfo != null) { 078 return edsInfo; 079 } else { 080 return super.getEntityByPrincipalId(principalId); 081 } 082 } 083 084 @Override 085 public Entity getEntityByPrincipalName(String principalName) { 086 if (StringUtils.isBlank(principalName)) { 087 throw new RiceIllegalArgumentException("principalName is blank"); 088 } 089 090 final Entity edsInfo = getPrincipalDao().getEntityByPrincipalName(principalName); 091 if (edsInfo != null) { 092 return edsInfo; 093 } else { 094 return super.getEntityByPrincipalName(principalName); 095 } 096 } 097 098 @Override 099 public EntityDefault getEntityDefault(String entityId) { 100 if (StringUtils.isBlank(entityId)) { 101 throw new RiceIllegalArgumentException("entityId is blank"); 102 } 103 104 EntityDefault edsInfo = getPrincipalDao().getEntityDefault(entityId); 105 if (edsInfo != null) { 106 return edsInfo; 107 } 108 else { 109 return super.getEntityDefault(entityId); 110 } 111 } 112 113 @Override 114 public EntityDefault getEntityDefaultByPrincipalId(String principalId) { 115 if (StringUtils.isBlank(principalId)) { 116 throw new RiceIllegalArgumentException("principalId is blank"); 117 } 118 119 final EntityDefault retval = getPrincipalDao().getEntityDefaultByPrincipalId(principalId); 120 if (retval != null) { 121 return retval; 122 } 123 else { 124 return super.getEntityDefaultByPrincipalId(principalId); 125 } 126 } 127 128 @Override 129 public EntityDefault getEntityDefaultByPrincipalName(String principalName) { 130 if (StringUtils.isBlank(principalName)) { 131 throw new RiceIllegalArgumentException("principalName is blank"); 132 } 133 134 final EntityDefault retval = getPrincipalDao().getEntityDefaultByPrincipalName(principalName); 135 if (retval != null) { 136 return retval; 137 } 138 else { 139 return super.getEntityDefaultByPrincipalName(principalName); 140 } 141 } 142 143 144 private static <U extends CriteriaValue<?>> Object getVal(U toConv) { 145 Object o = toConv.getValue(); 146 if (o instanceof DateTime) { 147 return new Timestamp(((DateTime) o).getMillis()); 148 } 149 return o; 150 } 151 152 /** 153 * Password lookups not supported by EDS. Use Natural Authentication strategies instead 154 * of this if that's what you need. 155 * 156 */ 157 @Override 158 @Deprecated 159 public Principal getPrincipalByPrincipalNameAndPassword(String principalName, String password) { 160 if (StringUtils.isBlank(principalName)) { 161 throw new RiceIllegalArgumentException("principalName is blank"); 162 } 163 164 //not validating password 165 166 return getPrincipalByPrincipalName(principalName); 167 } 168 169 @Override 170 public EntityPrivacyPreferences getEntityPrivacyPreferences(String entityId) { 171 if (StringUtils.isBlank(entityId)) { 172 throw new RiceIllegalArgumentException("entityId is blank"); 173 } 174 175 return getPrincipalDao().getEntityPrivacyPreferences(entityId); 176 } 177 178 @Override 179 public Principal getPrincipal(String principalId) { 180 if (StringUtils.isBlank(principalId)) { 181 throw new RiceIllegalArgumentException("principalId is blank"); 182 } 183 184 final Principal edsInfo = getPrincipalDao().getPrincipal(principalId); 185 if (edsInfo != null) { 186 return edsInfo; 187 } else { 188 return super.getPrincipal(principalId); 189 } 190 } 191 192 /** 193 * Gets a list of {@link org.kuali.rice.kim.api.identity.principal.Principal} from a string list of principalId. 194 * 195 * <p> 196 * This method will only return principals that exist. It will return null if the none of the principals exist. 197 * </p> 198 * 199 * @param principalIds the unique id to retrieve the principal by. cannot be null. 200 * @return a list of {@link org.kuali.rice.kim.api.identity.principal.Principal} or null 201 * @throws org.kuali.rice.core.api.exception.RiceIllegalArgumentException if the principalId is blank 202 */ 203 @Override 204 public List<Principal> getPrincipals(@WebParam(name = "principalIds") List<String> principalIds) { 205 List<Principal> ret = new ArrayList<Principal>(); 206 for(String p: principalIds) { 207 Principal principalInfo = getPrincipal(p); 208 209 if (principalInfo != null) { 210 ret.add(principalInfo) ; 211 } 212 } 213 return ret; 214 } 215 216 @Override 217 public Principal getPrincipalByPrincipalName(String principalName) { 218 if (StringUtils.isBlank(principalName)) { 219 throw new RiceIllegalArgumentException("principalName is blank"); 220 } 221 222 final Principal edsInfo = getPrincipalDao().getPrincipalByName(principalName); 223 if (edsInfo != null) { 224 return edsInfo; 225 } else { 226 return super.getPrincipalByPrincipalName(principalName); 227 } 228 } 229 230 public void setPrincipalDao(LdapPrincipalDao principalDao) { 231 this.principalDao = principalDao; 232 } 233 234 public LdapPrincipalDao getPrincipalDao() { 235 return principalDao; 236 } 237 }