ConferenceUserServiceImpl.java

/**
 * Licensed to Apereo under one or more contributor license
 * agreements. See the NOTICE file distributed with this work
 * for additional information regarding copyright ownership.
 * Apereo licenses this file to you under the Apache License,
 * Version 2.0 (the "License"); you may not use this file
 * except in compliance with the License.  You may obtain a
 * copy of the License at the following location:
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.jasig.portlet.blackboardvcportlet.service.impl;

import java.io.Serializable;
import java.util.Collections;
import java.util.Set;
import java.util.regex.Pattern;

import net.sf.ehcache.Ehcache;
import net.sf.ehcache.Element;

import org.jasig.portlet.blackboardvcportlet.dao.ConferenceUserDao;
import org.jasig.portlet.blackboardvcportlet.data.BasicUser;
import org.jasig.portlet.blackboardvcportlet.data.BasicUserImpl;
import org.jasig.portlet.blackboardvcportlet.data.ConferenceUser;
import org.jasig.portlet.blackboardvcportlet.security.ConferenceSecurityUser;
import org.jasig.portlet.blackboardvcportlet.security.ConferenceUserService;
import org.jasig.portlet.blackboardvcportlet.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.dao.support.DataAccessUtils;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContext;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Service;

import com.google.common.collect.ImmutableMap;

/**
 * Pulls the current user's email address out of spring-security and then does a lookup via the user dao
 */
@Service
public class ConferenceUserServiceImpl implements ConferenceUserService {
    private static final Pattern NAME_NORMALIZER = Pattern.compile("\\s+");

    private ConferenceUserDao conferenceUserDao;
    private UserService userService;
    private Ehcache userServiceCache;
    
    @Autowired
    @Qualifier("userServiceCache")
    public void setEhcache(Ehcache ehcache) {
        this.userServiceCache = ehcache;
    }

    @Autowired(required=false)
    public void setUserService(UserService userService) {
        this.userService = userService;
    }

    @Autowired
    public void setConferenceUserDao(ConferenceUserDao conferenceUserDao) {
        this.conferenceUserDao = conferenceUserDao;
    }

    @Override
    public ConferenceUser getCurrentConferenceUser() {
        final Authentication authentication = getCurrentAuthentication();
        if (authentication == null) {
            return null;
        }
        
        return getConferenceUser(authentication);
    }

    @Override
    public Authentication getCurrentAuthentication() {
        final SecurityContext context = SecurityContextHolder.getContext();
        return context.getAuthentication();
    }

    @Override
    public ConferenceUser getConferenceUser(Authentication authentication) {
        final ConferenceSecurityUser principal = (ConferenceSecurityUser)authentication.getPrincipal();
        if (principal == null) {
            return null;
        }
        
        final String uniqueId = principal.getUniqueId();
        return this.conferenceUserDao.getUserByUniqueId(uniqueId);
    }

    @Override
    public ConferenceUser getOrCreateConferenceUser(String displayName, String email) {
        return getOrCreateConferenceUser(new BasicUserImpl(null, email, displayName));
    }

    @Override
    public ConferenceUser getOrCreateConferenceUser(String uniqueId, String displayName, String email) {
        
        if (uniqueId != null) {
            final BasicUser basicUser = this.findBasicUser(uniqueId);
            if (basicUser != null) {
                return getOrCreateConferenceUser(basicUser);
            }
        }
        
        return getOrCreateConferenceUser(new BasicUserImpl(null, email, displayName));
    }

    @Override
    public ConferenceUser getOrCreateConferenceUser(BasicUser basicUser) {
        //If the uniqueId is specified try to find an existing user by uniqueId
        //if no existing user is found create a new internal user
        final String uniqueId = basicUser.getUniqueId();
        if (uniqueId != null) {
            ConferenceUser user = this.conferenceUserDao.getUserByUniqueId(uniqueId);
            if (user != null) {
                return user;
            }
            
            user = this.conferenceUserDao.createInternalUser(uniqueId);
            user.setDisplayName(basicUser.getDisplayName());
            user.setEmail(basicUser.getEmail());
            user.getAdditionalEmails().addAll(basicUser.getAdditionalEmails());
            
            return user;
        }
        
        final String email = basicUser.getEmail();
        
        //Try to find a single user by email, it potentially possible to have more than one
        //user entry with the same primary email address in the case of a user being able to
        //chose their address
        Set<ConferenceUser> users = this.conferenceUserDao.getUsersByPrimaryEmail(email);
        if (users.size() == 1) {
            return DataAccessUtils.requiredSingleResult(users);
        }
        
        //If no users were found with that primary address try to find users that have the email
        //listed in their "additional" email address set
        if (users.isEmpty()) {
            users = this.conferenceUserDao.getUsersByAnyEmail(email);
            if (users.size() == 1) {
                return DataAccessUtils.requiredSingleResult(users);
            }
        }
        
        //Fall back to treating the user as external
        final ConferenceUser user = this.conferenceUserDao.getExternalUserByEmail(email);
        if (user != null) {
            return user;
        }
        
        return this.conferenceUserDao.createExternalUser(basicUser.getDisplayName(), email);
    }
    
    @Override
    public BasicUser findBasicUser(String uniqueId) {
        //First check for a user in the local DB
        final ConferenceUser confUser = this.conferenceUserDao.getUserByUniqueId(uniqueId);
        if (confUser != null) {
            return confUser;
        }

        //Then see if there is a UserService to look in
        if (this.userService == null) {
            return null;
        }

        //Check the local cache of UserService results
        final Serializable cacheKey = createUniqueIdCacheKey(uniqueId);
        final Element element = this.userServiceCache.get(cacheKey);
        if (element != null) {
            return (BasicUser)element.getObjectValue();
        }
        
        //Check the UserService
        final BasicUser basicUser = this.userService.findUser(uniqueId);
        
        //If there is a hit cache the result
        if (basicUser != null) {
            this.userServiceCache.put(new Element(cacheKey, basicUser));
        }
        
        return basicUser;
    }

    @Override
    public Set<BasicUser> searchForBasicUserByName(String name) {
        if (this.userService == null) {
            //TODO could fall back to a local db search here
            return Collections.emptySet();
        }
        
        //Normalize the name to try and get extra oomf out of the cache
        final String normalizedName = NAME_NORMALIZER.matcher(name.trim()).replaceAll(" ");
        
        //Check the local cache of results
        final Serializable cacheKey = createNameSearchCacheKey(normalizedName);
        final Element element = this.userServiceCache.get(cacheKey);
        if (element != null) {
            return (Set<BasicUser>)element.getObjectValue();
        }
        
        //No cache, perform the search
        final Set<BasicUser> result = this.userService.searchForUserByName(normalizedName);
        
        //Cache the search result
        this.userServiceCache.put(new Element(cacheKey, result));
        cacheUsers(result);
        
        return result;
    }

    @Override
    public Set<BasicUser> searchForBasicUserByEmail(String email) {
        if (this.userService == null) {
            //TODO could fall back to a local db search here
            return Collections.emptySet();
        }
        
        //Normalize the email to try and get extra oomf out of the cache
        final String normalizedEmail = email.trim();
        
        //Check the local cache of results
        final Serializable cacheKey = createEmailSearchCacheKey(normalizedEmail);
        final Element element = this.userServiceCache.get(cacheKey);
        if (element != null) {
            return (Set<BasicUser>)element.getObjectValue();
        }
        
        //No cache, perform the search
        final Set<BasicUser> result = this.userService.searchForUserByEmail(normalizedEmail);
        
        //Cache the search result
        this.userServiceCache.put(new Element(cacheKey, result));
        cacheUsers(result);
        
        return result;
    }


    private void cacheUsers(final Set<BasicUser> result) {
        for (final BasicUser user : result) {
            final Serializable userCacheKey = this.createUniqueIdCacheKey(user.getUniqueId());
            this.userServiceCache.put(new Element(userCacheKey, user));
        }
    }

    private Serializable createUniqueIdCacheKey(String uniqueId) {
        return ImmutableMap.of("type", "findByUniqueId", "uniqueId", uniqueId.toUpperCase());
    }

    private Serializable createNameSearchCacheKey(String name) {
        return ImmutableMap.of("type", "searchByName", "name", name.toUpperCase());
    }

    private Serializable createEmailSearchCacheKey(String email) {
        return ImmutableMap.of("type", "searchByEmail", "email", email.toUpperCase());
    }
}