/*
 *  Copyright 2012 Anyware Services
 *
 *  Licensed 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
 *
 *      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.ametys.web.usermanagement;

import java.io.IOException;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Timestamp;
import java.time.LocalDate;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Optional;
import java.util.Set;
import java.util.UUID;
import java.util.stream.Collectors;

import org.apache.avalon.framework.configuration.Configuration;
import org.apache.avalon.framework.configuration.ConfigurationException;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang3.RandomStringUtils;
import org.apache.ibatis.session.RowBounds;
import org.apache.ibatis.session.SqlSession;

import org.ametys.cms.repository.Content;
import org.ametys.cms.transformation.xslt.ResolveURIComponent;
import org.ametys.core.datasource.AbstractMyBatisDAO;
import org.ametys.core.datasource.ConnectionHelper;
import org.ametys.core.right.RightManager;
import org.ametys.core.right.RightManager.RightResult;
import org.ametys.core.trace.ForensicLogger;
import org.ametys.core.ui.Callable;
import org.ametys.core.user.CurrentUserProvider;
import org.ametys.core.user.InvalidModificationException;
import org.ametys.core.user.User;
import org.ametys.core.user.User.UserCreationOrigin;
import org.ametys.core.user.UserIdentity;
import org.ametys.core.user.UserManager;
import org.ametys.core.user.directory.ModifiableUserDirectory;
import org.ametys.core.user.directory.NotUniqueUserException;
import org.ametys.core.user.directory.UserDirectory;
import org.ametys.core.user.directory.UserDirectoryFactory;
import org.ametys.core.user.directory.UserDirectoryModel;
import org.ametys.core.user.population.PopulationContextHelper;
import org.ametys.core.user.population.UserPopulation;
import org.ametys.core.user.population.UserPopulationDAO;
import org.ametys.core.util.I18nUtils;
import org.ametys.core.util.URIUtils;
import org.ametys.core.util.mail.SendMailHelper;
import org.ametys.plugins.repository.AmetysObjectIterable;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.query.expression.Expression;
import org.ametys.plugins.repository.query.expression.Expression.Operator;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.i18n.I18nizableTextParameter;
import org.ametys.runtime.parameter.Errors;
import org.ametys.web.renderingcontext.RenderingContext;
import org.ametys.web.renderingcontext.RenderingContextHandler;
import org.ametys.web.repository.page.Page;
import org.ametys.web.repository.page.PageQueryHelper;
import org.ametys.web.repository.page.Zone;
import org.ametys.web.repository.page.ZoneItem;
import org.ametys.web.repository.page.ZoneItem.ZoneType;
import org.ametys.web.repository.site.Site;
import org.ametys.web.repository.site.SiteManager;
import org.ametys.web.site.SiteConfigurationExtensionPoint;
import org.ametys.web.tags.TagExpression;
import org.ametys.web.usermanagement.UserManagementException.StatusError;
import org.ametys.web.usermanagement.UserSignupManager.TempUser.TempUserOrigin;

import com.google.common.collect.Multimap;

import jakarta.mail.MessagingException;

/**
 * Manages registration and password recovery of users.
 */
public class UserSignupManager extends AbstractMyBatisDAO
{

    /** The component role. */
    public static final String ROLE = UserSignupManager.class.getName();
    
    /** The site parameter name for signup type */
    public static final String SITE_PARAM_SIGNUP_TYPE = "signup-type";
    
    /** The Signup Service parameter : userDirectory */
    public static final String SIGNUP_SERVICE_PARAMETER_USERDIRECTORY = "userdirectory";
    
    /** Tag for signup pages */
    public static final String SIGNUP_PAGE_TAG_NAME = "USER_SIGNUP";
    
    /** Id of service for signup pages */
    public static final String SIGNUP_PAGE_SERVICE_ID = "org.ametys.web.service.UserSignup";
    
    /** Tag for password pages */
    public static final String CHANGE_PASSWORD_PAGE_TAG_NAME = "USER_PASSWORD_CHANGE";
    
    /** Id of service for signup pages */
    public static final String CHANGE_PASSWORD_PAGE_SERVICE_ID = "org.ametys.web.service.UserPassword";

    private static final String __EVENT_ACCOUNT_TEMP_SIGNUP = "account.temporary.signup";
    private static final String __EVENT_ACCOUNT_CREATED = "account.created";
    private static final String __EVENT_ACCOUNT_PASSWORD_RESET = "account.password.reset";
    private static final String __EVENT_ACCOUNT_PASSWORD_CHANGE = "account.password.change";
    private static final String __EVENT_ACCOUNT_PASSWORD_CHANGE_FAILED = "account.password.change.failed";

    /** The user manager. */
    protected UserManager _userManager;
    
    /** The DAO for user populations */
    protected UserPopulationDAO _userPopulationDAO;

    /** The site manager. */
    protected SiteManager _siteManager;

    /** The site configuration extension point. */
    protected SiteConfigurationExtensionPoint _siteConf;

    /** The ametys object resolver. */
    protected AmetysObjectResolver _resolver;

    /** The i18n utils. */
    protected I18nUtils _i18nUtils;

    /** The user sign up configuration */
    protected UserSignUpConfiguration _userSignUpConfiguration;
    
    /** The temporary users table. */
    protected String _tempUsersTable;

    /** The password change table. */
    protected String _pwdChangeTable;

    /** The population context helper. */
    protected PopulationContextHelper _populationContextHelper;

    /** The rendering context handler */
    protected RenderingContextHandler _renderingContextHandler;

    /** factory for user directory models */
    protected UserDirectoryFactory _userDirectoryFactory;

    /** The current user provider */
    protected CurrentUserProvider _currentUserProvider;

    /** The right manager */
    protected RightManager _rightManager;

    /**
     * Enumeration for the different type of signup
     *
     */
    public enum SignupType 
    {
        /** Signup is not authorized */
        UNAUTHORIZED,
        
        /** Signup allowed on invitation only */
        INVITATION_ONLY,
        
        /** Public signup allowed */
        PUBLIC
    }

    @Override
    public void service(ServiceManager serviceManager) throws ServiceException
    {
        super.service(serviceManager);
        
        _userManager = (UserManager) serviceManager.lookup(UserManager.ROLE);
        _userPopulationDAO = (UserPopulationDAO) serviceManager.lookup(UserPopulationDAO.ROLE);
        _siteManager = (SiteManager) serviceManager.lookup(SiteManager.ROLE);
        _siteConf = (SiteConfigurationExtensionPoint) serviceManager.lookup(SiteConfigurationExtensionPoint.ROLE);
        _resolver = (AmetysObjectResolver) serviceManager.lookup(AmetysObjectResolver.ROLE);
        _i18nUtils = (I18nUtils) serviceManager.lookup(I18nUtils.ROLE);
        _userSignUpConfiguration = (UserSignUpConfiguration) serviceManager.lookup(UserSignUpConfiguration.ROLE);
        _populationContextHelper = (PopulationContextHelper) serviceManager.lookup(PopulationContextHelper.ROLE);
        _renderingContextHandler = (RenderingContextHandler) serviceManager.lookup(RenderingContextHandler.ROLE);
        _userDirectoryFactory = (UserDirectoryFactory) serviceManager.lookup(UserDirectoryFactory.ROLE);
        _currentUserProvider = (CurrentUserProvider) serviceManager.lookup(CurrentUserProvider.ROLE);
        _rightManager = (RightManager) serviceManager.lookup(RightManager.ROLE);
    }
    

    @Override
    public void configure(Configuration configuration) throws ConfigurationException
    {
        super.configure(configuration);
        
        // Configure pool and tables.
        _tempUsersTable = configuration.getChild("temp-users-table").getValue();
        _pwdChangeTable = configuration.getChild("pwd-change-table").getValue();
    }

    /**
     * Get the type of signup authorized for this site
     * @param siteName the site name
     * @return the of signup
     */
    public SignupType getSignupType(String siteName)
    {
        Site site = _siteManager.getSite(siteName);
        String value = site.getValue(SITE_PARAM_SIGNUP_TYPE, false, SignupType.UNAUTHORIZED.name());
        return SignupType.valueOf(value.toUpperCase());
    }
    
    /**
     * Test if public signup is allowed in a site.
     * @param siteName the site to test.
     * @return true if public signup is allowed, false otherwise.
     */
    public boolean isPublicSignupAllowed(String siteName)
    {
        return getSignupType(siteName) == SignupType.PUBLIC;
    }
    
    /**
     * Test if signup is allowed in a site, public or on invitation
     * @param siteName the site to test.
     * @return true if signup is allowed, false otherwise.
     */
    public boolean isSignupAllowed(String siteName)
    {
        SignupType signupType = getSignupType(siteName);
        return signupType == SignupType.PUBLIC || signupType == SignupType.INVITATION_ONLY;
    }

    /**
     * Get the sign-up page in a given site and sitemap.<br>
     * If more than one page are tagged "sign-up", return the first.
     * @param siteName the site name.
     * @param language the sitemap name.
     * @return the sign-up page or null if not found.
     */
    public Page getSignupPage(String siteName, String language)
    {
        return getSignupPage(siteName, language, null, null);
    }
    
    /**
     * Get the sign-up page in a given site and sitemap, configured for given population and user directory.<br>
     * If more than one page are tagged "sign-up", return the first.
     * @param siteName the site name.
     * @param language the sitemap name.
     * @param populationId The population id. Can be null to not check population.
     * @param userDirectoryId The user directory id. Can be null to not check user directory.
     * @return the sign-up page or null if not found.
     */
    public Page getSignupPage(String siteName, String language, String populationId, String userDirectoryId)
    {
        List<Page> signupPages = getSignupPages(siteName, language, populationId, userDirectoryId);
        return signupPages.isEmpty() ? null : signupPages.get(0);
    }
    
    /**
     * Check if page is a signup page
     * @param page the page
     * @return true if the page contains the signup service
     */
    public boolean isSignupPage(Page page)
    {
        return _checkPageService(page, SIGNUP_PAGE_SERVICE_ID);
    }
    
    /**
     * Get all the pages tagged "sign-up" with signup service
     * @param siteName the site name.
     * @param language the sitemap name.
     * @return an iterable on all the pages tagged "sign-up".
     */
    public List<Page> getSignupPages(String siteName, String language)
    {
        return getSignupPages(siteName, language, null, null);
    }

    /**
     * Get all the pages tagged "sign-up" with signup service configured for given population and user directory
     * @param siteName the site name.
     * @param language the sitemap name.
     * @param populationId The population id. Can be null to not check population.
     * @param userDirectoryId The user directory id. Can be null to not check user directory.
     * @return an iterable on all the pages tagged "sign-up".
     */
    public List<Page> getSignupPages(String siteName, String language, String populationId, String userDirectoryId)
    {
        Expression expression = new TagExpression(Operator.EQ, SIGNUP_PAGE_TAG_NAME);
        String query = PageQueryHelper.getPageXPathQuery(siteName, language, null, expression, null);

        AmetysObjectIterable<Page> pages = _resolver.query(query);
        
        return pages.stream()
            .filter(p -> _checkSignupPage(p, populationId, userDirectoryId))
            .collect(Collectors.toList());
    }
    
    private boolean _checkPageService(Page page, String serviceId)
    {
        for (Zone zone : page.getZones())
        {
            try (AmetysObjectIterable<? extends ZoneItem> zoneItems = zone.getZoneItems())
            {
                for (ZoneItem zoneItem : zoneItems)
                {
                    if (zoneItem.getType() == ZoneType.SERVICE && serviceId.equals(zoneItem.getServiceId()))
                    {
                        return true;
                    }
                }
            }
        }
        
        return false;
    }
    
    private boolean _checkSignupPage(Page page, String populationId, String userDirectoryId)
    {
        for (Zone zone : page.getZones())
        {
            try (AmetysObjectIterable<? extends ZoneItem> zoneItems = zone.getZoneItems())
            {
                for (ZoneItem zoneItem : zoneItems)
                {
                    if (zoneItem.getType() == ZoneType.SERVICE && SIGNUP_PAGE_SERVICE_ID.equals(zoneItem.getServiceId()))
                    {
                        if (StringUtils.isEmpty(populationId) && StringUtils.isEmpty(userDirectoryId))
                        {
                            // No filter on user directory
                            return true;
                        }
                        else
                        {
                            UserDirectory userDirectory = getUserDirectory(zoneItem);
                            if (userDirectory != null && userDirectory.getId().equals(userDirectoryId) && userDirectory.getPopulationId().equals(populationId))
                            {
                                return true;
                            }
                        }
                    }
                }
            }
        }
        
        return false;
    }

    /**
     * Get the password change page in a given site and sitemap.
     * If more than one page are tagged "password change", return the first.
     * @param siteName the site name.
     * @param language the sitemap name.
     * @return the password change page or null if not found.
     */
    public Page getPwdChangePage(String siteName, String language)
    {
        List<Page> pwdChangePages = getPwdChangePages(siteName, language);
        return pwdChangePages.isEmpty() ? null : pwdChangePages.get(0);
    }
    
    /**
     * Get the GTU page
     * Returns null if not found or empty
     * @param zoneItem the zone item
     * @return the GTU page or null.
     */
    public Page getGTUPage(ZoneItem zoneItem)
    {
        Page page = null;

        try
        {
            String tosMode = zoneItem.getServiceParameters().getValue("terms-of-service-mode");
            if ("PAGE".equals(tosMode))
            {
                String tosPageId = zoneItem.getServiceParameters().getValue("terms-of-service-page");
                if (StringUtils.isNotEmpty(tosPageId))
                {
                    page = _resolver.resolveById(tosPageId);
                }
            }
        }
        catch (AmetysRepositoryException e)
        {
            // Nothing
        }

        return page;
    }
    
    /**
     * Get the user directory
     * @param zoneItem the zone item with signup service
     * @return The user directory or null if not found
     */
    public UserDirectory getUserDirectory(ZoneItem zoneItem)
    {
        try
        {
            String userDirectoryParameterValue = zoneItem.getServiceParameters().getValue(SIGNUP_SERVICE_PARAMETER_USERDIRECTORY);
            String[] populationAndDirectory = userDirectoryParameterValue.split("#", 2);
            String populationId = populationAndDirectory[0];
            String userDirectoryId = populationAndDirectory[1];
            
            UserPopulation userPopulation = _userPopulationDAO.getUserPopulation(populationId);
            if (userPopulation == null)
            {
                getLogger().error("The user population with id '{}' configured into service parameters of '{}' does not exist.", populationId, zoneItem.getId()); 
                return null;
            }
            return userPopulation.getUserDirectory(userDirectoryId);
        }
        catch (AmetysRepositoryException e)
        {
            getLogger().error("Failed to get user directory from service parameters of '{}'", zoneItem.getId(), e); 
            return null;
        }
    }
    
    
    /**
     * Get the GTU content
     * Returns null if not found or empty
     * @param zoneItem the zone item
     * @return the GTU content or null.
     */
    public Content getGTUContent(ZoneItem zoneItem)
    {
        Content content = null;

        try
        {
            String tosMode = zoneItem.getServiceParameters().getValue("terms-of-service-mode");
            if ("CONTENT".equals(tosMode))
            {
                String tosContentId = zoneItem.getServiceParameters().getValue("terms-of-service-content");
                if (StringUtils.isNotEmpty(tosContentId))
                {
                    content = _resolver.resolveById(tosContentId);
                }
            }
            
        }
        catch (AmetysRepositoryException e)
        {
            // Nothing
        }

        return content;
    }
    
    /**
     * Get the GTU page
     * Returns null if not found or empty
     * @param zoneItem the zone item
     * @return the success page or null.
     */
    public Page getSuccessPage(ZoneItem zoneItem)
    {
        Page page = null;

        try
        {
            String successMode = zoneItem.getServiceParameters().getValue("success-mode");
            if ("PAGE".equals(successMode))
            {
                String successPageId = zoneItem.getServiceParameters().getValue("success-page");
                if (StringUtils.isNotEmpty(successPageId))
                {
                    page = _resolver.resolveById(successPageId);
                }
            }
        }
        catch (AmetysRepositoryException e)
        {
            // Nothing
        }

        return page;
    }
    
    /**
     * Get the success content
     * Returns null if not found or empty
     * @param zoneItem the zone item
     * @return the success content or null.
     */
    public Content getSuccessContent(ZoneItem zoneItem)
    {
        Content content = null;

        try
        {
            String successMode = zoneItem.getServiceParameters().getValue("success-mode");
            if ("CONTENT".equals(successMode))
            {
                String successContentId = zoneItem.getServiceParameters().getValue("success-content");
                if (StringUtils.isNotEmpty(successContentId))
                {
                    content = _resolver.resolveById(successContentId);
                }
            }
        }
        catch (AmetysRepositoryException e)
        {
            // Nothing
        }

        return content;
    }

    /**
     * Get all the pages tagged "password change".
     * @param siteName the site name.
     * @param language the sitemap name.
     * @return an iterable on all the pages tagged "password change".
     */
    public List<Page> getPwdChangePages(String siteName, String language)
    {
        Expression expression = new TagExpression(Operator.EQ, CHANGE_PASSWORD_PAGE_TAG_NAME);
        String query = PageQueryHelper.getPageXPathQuery(siteName, language, null, expression, null);

        AmetysObjectIterable<Page> pages = _resolver.query(query);
        
        return pages.stream()
            .filter(p -> _checkPageService(p, CHANGE_PASSWORD_PAGE_SERVICE_ID))
            .collect(Collectors.toList());
    }
    
    /**
     * Check if page is a change password page
     * @param page the page
     * @return true if the page contains the change password service
     */
    public boolean isPwdChangePage(Page page)
    {
        return _checkPageService(page, CHANGE_PASSWORD_PAGE_SERVICE_ID);
    }
    
    /**
     * Get the user from email if he/she exists in the populations 
     * @param email the e-mail to test.
     * @param siteName The site name
     * @return the user if the user exists, empty otherwise.
     * @throws UserManagementException if an error occurs.
     * @throws NotUniqueUserException if several user respond to the email
     */
    public Optional<User> getUserIfHeExists(String email, String siteName) throws UserManagementException, NotUniqueUserException
    {
        Set<String> populationIds = _populationContextHelper.getUserPopulationsOnContexts(Arrays.asList("/sites/" + siteName, "/sites-fo/" + siteName), false, false);
        for (String population : populationIds)
        {
            User user = _userManager.getUser(population, email);
            if (user != null)
            {
                return Optional.of(user);
            }
            else
            {
                User userByEmail = _userManager.getUserByEmail(population, email);
                if (userByEmail != null)
                {
                    return Optional.of(userByEmail);
                }
            }
        }
        
        return Optional.empty();
    }
    
    /**
     * Tests if the user already exists in the populations 
     * @param email the e-mail to test.
     * @param siteName The site name
     * @return true if the user exists, false otherwise.
     * @throws UserManagementException if an error occurs.
     */
    public boolean userExists(String email, String siteName) throws UserManagementException
    {
        try
        {
            return getUserIfHeExists(email, siteName).isPresent();
        }
        catch (NotUniqueUserException e)
        {
            return true;
        }
    }

    /**
     * Validate the user subscription data.
     * @param siteName the site name.
     * @param email the user e-mail.
     * @param additionalValues the additional user values.
     * @return a Map of the Errors by field.
     * @throws UserManagementException if an error occurs.
     */
    public Map<String, Errors> validate(String siteName, String email, Map<String, String> additionalValues) throws UserManagementException
    {
        Map<String, String> userInfos = new HashMap<>();
        
        userInfos.putAll(additionalValues);
        
        // Standard info for user (provide a dummy password, as we do not know it yet).
        userInfos.put("login", email);
        userInfos.put("email", email);
        userInfos.put("password", "password");

        Map<String, Errors> usersManagerErrors = new HashMap<>(); //foUsersManager.validate(userInfos);
        Map<String, Errors> errors = new HashMap<>(usersManagerErrors);

        // If there are errors on the login, do not return it except if
        if (errors.containsKey("login"))
        {
            if (!errors.containsKey("email"))
            {
                errors.put("email", errors.get("login"));
            }
            errors.remove("login");
        }

        return errors;
    }

    /**
     * Validate the user password.
     * @param siteName the site name.
     * @param password the password to validate.
     * @param login the login of the user
     * @param population The id of the population
     * @return a Map of the Errors by field.
     * @throws UserManagementException if an error occurs.
     */
    public Map<String, Errors> validatePassword(String siteName, String password, String login, String population) throws UserManagementException
    {
        Map<String, String> userInfos = new HashMap<>();

        userInfos.put("password", password);

        UserDirectory userDirectory = _userManager.getUserDirectory(population, login);
        if (!(userDirectory instanceof ModifiableUserDirectory))
        {
            throw new UserManagementException("The user subscription feature can't be used, as the UserDirectory is not modifiable.", StatusError.UNMODIFIABLE_USER_DIRECTORY);
        }
        Map<String, Errors> usersManagerErrors = ((ModifiableUserDirectory) userDirectory).validate(userInfos);
        Map<String, Errors> errors = new HashMap<>();

        // Keep only errors related to the password field.
        if (usersManagerErrors.containsKey("password"))
        {
            errors.put("password", usersManagerErrors.get("password"));
        }

        return errors;
    }
    
    /**
     * Temporary sign the user in and returns the token
     * @param siteName The site's name
     * @param language The page's language
     * @param email The email of the user
     * @param population The population ID
     * @param userDirectoryId The userDirectory ID
     * @return The sign-up token
     * @throws UserManagementException If an error occurs
     */
    public String getOrCreateToken(String siteName, String language, String email, String population, String userDirectoryId) throws UserManagementException 
    {
        String token = getToken(siteName, email, population, userDirectoryId);
        
        if (token == null)
        {
            temporarySignup(siteName, language, email, population, userDirectoryId, false);
            token = getToken(siteName, email, population, userDirectoryId);
        }
        
        return token;
    }
    
    /**
     * Validate and store a sign-up request and send a confirmation e-mail.
     * @param siteName the site name.
     * @param language the sitemap name.
     * @param email the user e-mail address.
     * @param population the population
     * @param userDirectoryId the id of the user directory of the population
     * @throws UserManagementException if an error occurs.
     */
    public void temporarySignup(String siteName, String language, String email, String population, String userDirectoryId) throws UserManagementException
    {
        temporarySignup(siteName, language, email, population, userDirectoryId, true);
    }
    
    /**
     * Validate and store a sign-up request and send a confirmation e-mail.
     * @param siteName the site name.
     * @param language the sitemap name.
     * @param email the user e-mail address.
     * @param population the population
     * @param userDirectoryId the id of the user directory of the population
     * @param sendMail Set to false to not send mail at end of process
     * @throws UserManagementException if an error occurs.
     */
    public void temporarySignup(String siteName, String language, String email, String population, String userDirectoryId, boolean sendMail) throws UserManagementException
    {
        // Verify that public sign-up is allowed and throw an exception otherwise.
        checkPublicSignup(siteName);

        if (getLogger().isDebugEnabled())
        {
            getLogger().debug("A user is requesting a sign-up: " + email);
        }

        _temporarySignup(siteName, language, email, population, userDirectoryId, null, null, TempUserOrigin.USER_REQUEST, sendMail, false);
    }
    
    /**
     * Validate and store a invitation to sign-up request and send a confirmation e-mail.
     * @param siteName the site name.
     * @param language the sitemap name.
     * @param email the user e-mail address.
     * @param population the population
     * @param userDirectoryId the id of the user directory of the population
     * @param lastname The guest last name. Can be null.
     * @param firstname The guest first name. Can be null.
     * @throws UserManagementException if an error occurs.
     */
    public void inviteToSignup(String siteName, String language, String email, String population, String userDirectoryId, String lastname, String firstname) throws UserManagementException
    {
        inviteToSignup(siteName, language, email, population, userDirectoryId, lastname, firstname, true, true, true);
    }
    
    /**
     * Validate and store a invitation to sign-up request and send a confirmation e-mail.
     * @param siteName the site name.
     * @param language the sitemap name.
     * @param email the user e-mail address.
     * @param population the population
     * @param userDirectoryId the id of the user directory of the population
     * @param lastname The guest last name. Can be null.
     * @param firstname The guest first name. Can be null.
     * @param sendMail Set to false to not send mail at end of process
     * @param resendInvitationIfExists Set to false to not resend invitation if the email already exists as a user waiting signup
     * @param checkRights set to false to ignore rights
     * @throws UserManagementException if an error occurs.
     */
    public void inviteToSignup(String siteName, String language, String email, String population, String userDirectoryId, String lastname, String firstname, boolean sendMail, boolean resendInvitationIfExists, boolean checkRights) throws UserManagementException
    {
        // Verify that sign-up is allowed (public or on invitation only) and throw an exception otherwise.
        checkSignupAllowed(siteName);
        
        if (checkRights)
        {
            // Verify that user is allowed to send invitation for this population and throw an exception otherwise.
            checkUserAllowedForInvitation(siteName, population);
        }
        
        if (getLogger().isDebugEnabled())
        {
            getLogger().debug("A user is invited to sign-up: " + email);
        }
        
        _temporarySignup(siteName, language, email, population, userDirectoryId, lastname, firstname, TempUserOrigin.INVITATION, sendMail, resendInvitationIfExists);
    }
    
    private void _temporarySignup(String siteName, String language, String email, String population, String userDirectoryId, String lastname, String firstname, TempUserOrigin origin, boolean sendMail, boolean resendInvitationIfExists) throws UserManagementException
    {
        if (userExists(email, siteName))
        {
            throw new UserManagementException("User with email " + email  + " already exists", StatusError.USER_ALREADY_EXISTS);
        }
        
        // Generate unique token.
        String token = UUID.randomUUID().toString().replace("-", "");

        try
        {
            addTemporaryUser(siteName, email, token, population, userDirectoryId, lastname, firstname, origin);
            
            // Send validation e-mail with token.
            if (sendMail)
            {
                TempUser tempUser = getTempUser(siteName, email, population, userDirectoryId);
                sendSignupConfirmMail(tempUser, language);
            }
            
            ForensicLogger.info(__EVENT_ACCOUNT_TEMP_SIGNUP, Map.of("site", siteName, "email", email, "population", population, "userDirectory", userDirectoryId), null);
        }
        catch (UserManagementException e)
        {
            if (e.getStatusError() == StatusError.TEMP_USER_ALREADY_EXISTS && resendInvitationIfExists)
            {
                // Ignore error and resend the invitation if the temporary user was already registered
                resendInvitation(siteName, email, population, userDirectoryId);
                return;
            }
            else
            {
                // Remove the temporary user that was potentially created (as the temporary signup could not complete successfully)
                removeTempUser(siteName, email, token, population, userDirectoryId);
                throw e;
            }
        }
        
    }
    
    /**
     * Get a token for temp user
     * @param siteName the site name.
     * @param email the user e-mail address.
     * @param population The id of the population
     * @param userDirectoryId The id of the user directory of the population
     * @return the user token or null if not found
     * @throws UserManagementException if an error occurs.
     */
    public String getToken(String siteName, String email, String population, String userDirectoryId) throws UserManagementException
    {
        TempUser tempUser = getTempUser(siteName, email, population, userDirectoryId);
        if (tempUser != null)
        {
            return tempUser.getToken();
        }
        
        return null;
    }
    
    /**
     * Update susbcription date and resend an invitation
     * @param siteName the site name
     * @param email the email
     * @param population the population id
     * @param userDirectoryId the user directory id
     * @throws UserManagementException if an error occurred
     */
    public void resendInvitation(String siteName, String email, String population, String userDirectoryId) throws UserManagementException
    {
        // Verify that sign-up is allowed and throw an exception otherwise.
        checkSignupAllowed(siteName);
        
        // Verify that user is allowed  and throw an exception otherwise.
        checkUserAllowedForInvitation(siteName, population);
        
        TempUser tempUser = getTempUser(siteName, email, population, userDirectoryId);
        if (tempUser.getOrigin() != TempUserOrigin.INVITATION)
        {
            throw new UserManagementException("Can not resend invitation. The subscription request is a user request", StatusError.UNMODIFIABLE_SIGNUP_REQUEST);
        }
        
        // Reset signup without generating new token
        resetTempSignup(siteName, null, email, null, population, userDirectoryId);
    }

    /**
     * Reset a sign-up request: generate a new token and re-send the confirmation e-mail.
     * @param siteName the site name.
     * @param language the sitemap name.
     * @param email the user e-mail address.
     * @param population The id of the population
     * @param userDirectoryId The id of the user directory of the population
     * @throws UserManagementException if an error occurs.
     */
    public void resetTempSignup(String siteName, String language, String email, String population, String userDirectoryId) throws UserManagementException
    {
        // Verify that public sign-up is allowed and throw an exception otherwise.
        checkPublicSignup(siteName);
        
        // Generate a new token.
        String newToken = UUID.randomUUID().toString().replace("-", "");
        
        if (getLogger().isDebugEnabled())
        {
            getLogger().debug("Resetting temporary signup for email: " + email + " in site " + siteName);
        }
        
        resetTempSignup(siteName, language, email, newToken, population, userDirectoryId);
    }
    
    /**
     * Reset a sign-up request: generate a new token and re-send the confirmation e-mail.
     * @param siteName the site name.
     * @param language the sitemap name.
     * @param email the user e-mail address.
     * @param token the token. Can be null to not re-generate token.
     * @param population The id of the population
     * @param userDirectoryId The id of the user directory of the population
     * @throws UserManagementException if an error occurs.
     */
    protected void resetTempSignup(String siteName, String language, String email, String token, String population, String userDirectoryId) throws UserManagementException
    {
        // Test if the subscription request really exists.
        TempUser tempUser = getTempUser(siteName, email, population, userDirectoryId);

        if (tempUser == null)
        {
            throw new UserManagementException("Found no subscription request with email '" + email + "' for site '" + siteName + "'", StatusError.UNKNOWN_EMAIL);
        }
        
        String newToken = token;
        if (newToken == null)
        {
            // No generate new token
            newToken = tempUser.getToken();
        }
        
        updateTempToken(siteName, email, newToken, population, userDirectoryId);
        
        tempUser = getTempUser(siteName, email, population, userDirectoryId);

        sendSignupConfirmMail(tempUser, language);
    }


    /**
     * Create the user in the FO UsersManager from his temporary request.
     * @param siteName the site name.
     * @param language the current language
     * @param firstname the user firstname
     * @param lastname the user lastname
     * @param email the user e-mail address.
     * @param token the request token.
     * @param password the user password.
     * @param population The id of the population
     * @param userDirectoryId The id of the user directory of the population
     * @param errors the errors
     * @throws UserManagementException if an error occurs.
     */
    public void signup(String siteName, String language, String firstname, String lastname, String email, String token, String password, String population, String userDirectoryId, Multimap<String, I18nizableText> errors) throws UserManagementException
    {
        // Verify that public sign-up is allowed and throw an exception otherwise.
        checkSignupAllowed(siteName);

        Map<String, String> userInfos = new HashMap<>();

        TempUser tempUser = getTempUser(siteName, email, token, population, userDirectoryId);

        if (tempUser == null)
        {
            throw new UserManagementException("Provided token is unknown", StatusError.TOKEN_UNKNOWN);
        }
        
        // Generate login
        String login = RandomStringUtils.randomNumeric(10);

        // Standard info for user.
        userInfos.put("login", login);
        userInfos.put("email", email);
        userInfos.put("firstname", firstname);
        userInfos.put("lastname", lastname);
        userInfos.put("password", password);

        try
        {
            validationBeforeSignup(errors);
            
            if (errors.isEmpty())
            {
                // Add the user.
                ModifiableUserDirectory userDirectory = (ModifiableUserDirectory) _userPopulationDAO.getUserPopulation(population).getUserDirectory(userDirectoryId);
                userDirectory.add(userInfos, UserCreationOrigin.USER_SIGNUP);

                // Remove the temporary user.
                removeTempUser(siteName, email, token, population, userDirectoryId);
                
                User createdUser = userDirectory.getUser(login);
                
                // Do additional operations after signup
                additionalSignupOperations(createdUser, errors);
                
                if (errors.isEmpty())
                {
                    sendSignupValidatedMail(siteName, language, createdUser);
                    
                    ForensicLogger.info(__EVENT_ACCOUNT_CREATED, Map.of("site", siteName, "user", createdUser, "population", population, "userDirectory", userDirectoryId), createdUser.getIdentity());
                }
            }
            else
            {
                throw new UserManagementException("Unable to signup user");
            }
            
        }
        catch (InvalidModificationException e)
        {
            throw new UserManagementException("An error occurred signing up the user.", StatusError.INVALID_MODIFICATION, e);
        }
    }
    
    /**
     * Do some validation before signup
     * @param errors the map of errors to fill in cause of errors during validation
     */
    public void validationBeforeSignup(Multimap<String, I18nizableText> errors)
    {
        // Nothing
    }
    
    /**
     * Process additional operations after creation of user
     * @param createdUser the created user
     * @param errors the map of errors to fill in case of errors during additional operations
     * @throws UserManagementException if an error occurs.
     */
    public void additionalSignupOperations(User createdUser, Multimap<String, I18nizableText> errors) throws UserManagementException
    {
        // Nothing
    }
    

    /**
     * Create a reset password request and send a confirmation e-mail.
     * @param siteName the site name.
     * @param language the sitemap name.
     * @param loginOrEmail the user login or email.
     * @param populationId the population
     * @throws UserManagementException if an error occurs.
     */
    public void resetPassword(String siteName, String language, String loginOrEmail, String populationId) throws UserManagementException
    {
        // Check if the population exists
        UserPopulation population = _userPopulationDAO.getUserPopulation(populationId);
        if (population == null)
        {
            throw new UserManagementException("Unknown population with id '" + populationId + "'", StatusError.POPULATION_UNKNOWN);
        }
        
        // Check if the user exists and get it
        User user = _userManager.getUser(populationId, loginOrEmail);
        if (user == null)
        {
            try
            {
                user = _userManager.getUserByEmail(populationId, loginOrEmail);
                if (user == null)
                {
                    // No user with this e-mail or login.
                    throw new UserManagementException("Unknown user with login or email '" + loginOrEmail + "' for population '" + populationId + "'", StatusError.USER_UNKNOWN);
                }
            }
            catch (NotUniqueUserException e)
            {
                throw new UserManagementException("Many users match for email '" + loginOrEmail + "' and population '" + populationId + "'", StatusError.NOT_UNIQUE_USER);
            }
        }
        
        // Check if the user directory is modifiable
        if (!(user.getUserDirectory() instanceof ModifiableUserDirectory))
        {
            throw new UserManagementException("User directory is not modifiable", StatusError.UNMODIFIABLE_USER_DIRECTORY);
        }
        
        if (StringUtils.isEmpty(user.getEmail()))
        {
            throw new UserManagementException("User has no email", StatusError.EMPTY_EMAIL);
        }

        // Generate a new token.
        String token = UUID.randomUUID().toString().replace("-", "");

        // Insert the token in the database.
        addPasswordToken(siteName, user.getIdentity().getLogin(), token, populationId);

        // Send the e-mail.
        sendResetPasswordMail(siteName, language, user, token);
        
        // Trace event
        ForensicLogger.info(__EVENT_ACCOUNT_PASSWORD_RESET, Map.of("site", siteName, "user", user), user.getIdentity());
    }

    /**
     * Change the user password.
     * @param siteName the site name.
     * @param login the user login.
     * @param token the password change request token.
     * @param newPassword the new password.
     * @param population the population
     * @throws UserManagementException if an error occurs.
     */
    public void changeUserPassword(String siteName, String login, String token, String newPassword, String population) throws UserManagementException
    {
        checkPasswordToken(siteName, login, token, population);

        Map<String, String> userInfos = new HashMap<>();

        userInfos.put("login", login);
        userInfos.put("password", newPassword);

        try
        {
            UserDirectory userDirectory = _userManager.getUserDirectory(population, login);
            if (!(userDirectory instanceof ModifiableUserDirectory))
            {
                _logPasswordChangeFailed(siteName, login, population, "unmodifiable-modification");
                throw new UserManagementException("The user's password can't be changed, as the UserDirectory is not modifiable.", StatusError.UNMODIFIABLE_USER_DIRECTORY);
            }
            ((ModifiableUserDirectory) userDirectory).update(userInfos);

            removePasswordToken(siteName, login, token, population);
            
            ForensicLogger.info(__EVENT_ACCOUNT_PASSWORD_CHANGE, Map.of("site", siteName, "login", login, "population", population), new UserIdentity(login, population));
        }
        catch (InvalidModificationException e)
        {
            _logPasswordChangeFailed(siteName, login, population, "invalid-modification");
            throw new UserManagementException("Invalid user inputs to change password", StatusError.INVALID_MODIFICATION, e);
        }
    }
    
    private void _logPasswordChangeFailed(String siteName, String login, String population, String errorCause)
    {
        Map<String, Object> eventArgs = Map.of("site", siteName, "login", login, "population", population, "error", errorCause);
        ForensicLogger.warn(__EVENT_ACCOUNT_PASSWORD_CHANGE_FAILED, eventArgs, new UserIdentity(login, population));
    }
    
    /**
     * Check the sign-up request token.
     * @param siteName the site name.
     * @param email the user e-mail.
     * @param token the sign-up request token.
     * @param population The id of the population
     * @param userDirectoryId The id of the user directory of the population
     * @throws UserManagementException if an error occurs.
     */
    public void checkToken(String siteName, String email, String token, String population, String userDirectoryId) throws UserManagementException
    {
        removeExpiredTokens();

        try (SqlSession sqlSession = getSession())
        {
            String stmtId = "UserSignupManager.getSubscriptionDate";
            
            Map<String, Object> params = new HashMap<>();
            params.put("tempUsersTable", _tempUsersTable);
            
            params.put("site", siteName);
            params.put("email", email);
            params.put("token", token);
            params.put("population", population);
            params.put("userDirectory", userDirectoryId);
            
            Date rawSubscriptionDate = sqlSession.selectOne(stmtId, params);

            // Date verification.
            if (rawSubscriptionDate == null)
            {
                throw new UserManagementException("Provided token is unknown", StatusError.TOKEN_UNKNOWN);
            }
            
            // The validity limit
            ZonedDateTime limit = LocalDate.now().atStartOfDay(ZoneId.systemDefault()).minusDays(_userSignUpConfiguration.getTokenValidity());
            ZonedDateTime subscriptionDate = rawSubscriptionDate.toInstant().atZone(ZoneId.systemDefault());

            if (subscriptionDate.isBefore(limit))
            {
                throw new UserManagementException("Provided token is expired", StatusError.TOKEN_EXPIRED);
            }
        }
        catch (Exception e)
        {
            if (e instanceof UserManagementException)
            {
                throw e;
            }
            else
            {
                throw new UserManagementException("Database error while testing the token for user [" + email + "]", StatusError.DATABASE_ERROR, e);
            }
        }
    }

    /**
     * Check the password change request token.
     * @param siteName the site name.
     * @param login the user login.
     * @param token the password change request token.
     * @param population the population
     * @throws UserManagementException if an error occurs.
     */
    public void checkPasswordToken(String siteName, String login, String token, String population) throws UserManagementException
    {
        removeExpiredPasswordTokens();

        try (SqlSession sqlSession = getSession())
        {
            String stmtId = "UserSignupManager.getRequestDate";
            
            Map<String, Object> params = new HashMap<>();
            params.put("pwdChangeTable", _pwdChangeTable);
            
            params.put("site", siteName);
            params.put("login", login);
            params.put("token", token);
            params.put("population", population);
            
            Date rawRequestDate = sqlSession.selectOne(stmtId, params);

            // Date verification.
            if (rawRequestDate == null)
            {
                throw new UserManagementException("Provided token for login '" + login + "' and site '" + siteName + "' is unknown", StatusError.TOKEN_UNKNOWN);
            }

            // Check the validity.
            ZonedDateTime limit = LocalDate.now().atStartOfDay(ZoneId.systemDefault()).minusDays(_userSignUpConfiguration.getTokenValidity());
            ZonedDateTime requestDate = rawRequestDate.toInstant().atZone(ZoneId.systemDefault());

            if (requestDate.isBefore(limit))
            {
                throw new UserManagementException("Provided token for login '" + login + "' and site '" + siteName + "' is expired", StatusError.TOKEN_EXPIRED);
            }
        }
        catch (Exception e)
        {
            if (e instanceof UserManagementException)
            {
                throw e;
            }
            else
            {
                throw new UserManagementException("Database error while testing the password token for user " + login, StatusError.DATABASE_ERROR, e);
            }
        }
    }
    
    /**
     * Remove the expired sign-up request tokens (user request only)
     * @throws UserManagementException if an error occurs.
     */
    public void removeExpiredTokens() throws UserManagementException
    {
        removeExpiredTokens(null);
    }

    /**
     * Remove the expired sign-up request tokens (user request only)
     * @param siteName the site name. Can be null.
     * @return the number of deleted tokens
     * @throws UserManagementException if an error occurs.
     */
    public int removeExpiredTokens(String siteName) throws UserManagementException
    {
        try (SqlSession sqlSession = getSession())
        {
            String stmtId = "UserSignupManager.deleteExpiredTokens";
            
            Map<String, Object> params = new HashMap<>();
            params.put("tempUsersTable", _tempUsersTable);
            
            ZonedDateTime limit = LocalDate.now().atStartOfDay(ZoneId.systemDefault()).minusDays(_userSignUpConfiguration.getTokenValidity());
            Timestamp limitTimestamp = Timestamp.from(limit.toInstant());
            params.put("threshold", limitTimestamp);
            if (StringUtils.isNotBlank(siteName))
            {
                params.put("site", siteName);
            }
            
            int deletedTokens = sqlSession.delete(stmtId, params);
            sqlSession.commit();
            return deletedTokens;
        }
        catch (Exception e)
        {
            throw new UserManagementException("Database error while removing the expired tokens.", StatusError.DATABASE_ERROR, e);
        }
    }

    /**
     * Remove the expired change password request tokens.
     * @throws UserManagementException if an error occurs.
     */
    public void removeExpiredPasswordTokens() throws UserManagementException
    {
        try (SqlSession sqlSession = getSession())
        {
            String stmtId = "UserSignupManager.deleteExpiredPasswordTokens";
            
            Map<String, Object> params = new HashMap<>();
            params.put("pwdChangeTable", _pwdChangeTable);
            
            ZonedDateTime limit = LocalDate.now().atStartOfDay(ZoneId.systemDefault()).minusDays(_userSignUpConfiguration.getTokenValidity());
            Timestamp limitTimestamp = Timestamp.from(limit.toInstant());
            params.put("threshold", limitTimestamp);
            
            sqlSession.delete(stmtId, params);
            sqlSession.commit();
        }
        catch (Exception e)
        {
            throw new UserManagementException("Database error while removing the expired tokens.", StatusError.DATABASE_ERROR, e);
        }
    }

    /**
     * Verify that public sign-up is allowed. If not, throw an exception.
     * @param siteName the site name.
     * @throws UserManagementException if public sign-up is not enabled.
     */
    protected void checkPublicSignup(String siteName) throws UserManagementException
    {
        if (!isPublicSignupAllowed(siteName))
        {
            throw new UserManagementException("Public signup is disabled for this site.", StatusError.PUBLIC_SIGNUP_NOT_ALLOWED);
        }
    }
    
    /**
     * Verify that public sign-up is allowed. If not, throw an exception.
     * @param siteName the site name.
     * @throws UserManagementException if public sign-up is not enabled.
     */
    protected void checkSignupAllowed(String siteName) throws UserManagementException
    {
        if (!isSignupAllowed(siteName))
        {
            throw new UserManagementException("Signup is disabled for this site.", StatusError.SIGNUP_NOT_ALLOWED);
        }
    }

    /**
     * Create a user sign-up request ("temporary" user) in the database.
     * @param siteName the site name.
     * @param email the user e-mail.
     * @param token the generated token.
     * @param population the population
     * @param userDirectoryId the id of the user directory of the population
     * @param lastname The guest last name. Can be null.
     * @param firstname The guest first name. Can be null.
     * @param origin true if this signup request origin
     * @throws UserManagementException if an error occurs.
     */
    protected void addTemporaryUser(String siteName, String email, String token, String population, String userDirectoryId, String lastname, String firstname, TempUserOrigin origin) throws UserManagementException
    {
        try (SqlSession sqlSession = getSession())
        {
            // Does this email already exists
            String stmtId = "UserSignupManager.tempEmailExists";
            
            Map<String, Object> params = new HashMap<>();
            params.put("tempUsersTable", _tempUsersTable);
            
            params.put("site", siteName);
            params.put("email", email);
            
            List<String> emails = sqlSession.selectList(stmtId, params);
            
            if (!emails.isEmpty())
            {
                throw new UserManagementException("Temporary user with email '" + email + "' and site name '" + siteName + "' already exists", StatusError.TEMP_USER_ALREADY_EXISTS);
            }
            
            // Add temporary user
            stmtId = "UserSignupManager.addTempUser";
            params = new HashMap<>();
            params.put("tempUsersTable", _tempUsersTable);
            
            Timestamp now = new Timestamp(System.currentTimeMillis());
            
            params.put("site", siteName);
            params.put("email", email);
            params.put("population", population);
            params.put("userDirectory", userDirectoryId);
            params.put("subscription_date", now);
            params.put("token", token);
            params.put("lastname", lastname);
            params.put("firstname", firstname);
            params.put("origin", origin.name());
            
            sqlSession.insert(stmtId, params);
            sqlSession.commit();
        }
        catch (Exception e)
        {
            if (e instanceof UserManagementException)
            {
                throw e;
            }
            else
            {
                throw new UserManagementException("Database error while signing up a new user [" + email + "]", StatusError.DATABASE_ERROR, e);
            }
        }
    }

    /**
     * Send a sign-up confirmation link by e-mail.
     * @param tempUser the temp user
     * @param language the e-mail language.
     * @throws UserManagementException if an error occurs.
     */
    protected void sendSignupConfirmMail(TempUser tempUser, String language) throws UserManagementException
    {
        String email = tempUser.getEmail();
        String siteName = tempUser.getSite();
        String populationId = tempUser.getPopulation();
        String userDirectoryId = tempUser.getUserDirectoryId();
        String token = tempUser.getToken();
        String lastname = tempUser.getLastname();
        String firstname = tempUser.getFirstname();
        String fullname = (StringUtils.isEmpty(firstname) ? "" : " " + firstname) + (StringUtils.isEmpty(lastname) ? "" : " " + lastname);
        boolean fromInvitation = tempUser.getOrigin() == TempUserOrigin.INVITATION;
        
        if (getLogger().isDebugEnabled())
        {
            getLogger().debug("Sending signup confirmation e-mail to " + email);
        }

        Site site = _siteManager.getSite(siteName);
        String from = site.getValue("site-mail-from");
        
        if (!SendMailHelper.EMAIL_VALIDATION.matcher(StringUtils.trimToEmpty(email)).matches())
        {
            throw new UserManagementException("Cannot send signup email. The email is invalid [" + email + "]", StatusError.INVALID_EMAIL);
        }

        // Prepare mail.
        Map<String, I18nizableTextParameter> i18nParams = new HashMap<>();
        i18nParams.put("siteName", new I18nizableText(siteName));
        i18nParams.put("email", new I18nizableText(email));
        i18nParams.put("fullName", new I18nizableText(fullname));
        i18nParams.put("token", new I18nizableText(tempUser.getToken()));
        i18nParams.put("tokenValidity", new I18nizableText(String.valueOf(_userSignUpConfiguration.getTokenValidity())));
        
        Page signupPage = getSignupPage(siteName, language, populationId, userDirectoryId);
        if (signupPage != null)
        {
            RenderingContext currentContext = _renderingContextHandler.getRenderingContext();
            
            try
            {
                // Force front context to resolver signup page uri
                _renderingContextHandler.setRenderingContext(RenderingContext.FRONT);
                
                String encodedEmail = URIUtils.encodeParameter(email);
                
                String confirmUri = ResolveURIComponent.resolve("page", signupPage.getId(), false, true);
                confirmUri = confirmUri + "?email=" + encodedEmail + "&token=" + token;
                
                if (StringUtils.isNotEmpty(lastname))
                {
                    confirmUri += "&lastname=" + URIUtils.encodeParameter(lastname);
                }
                if (StringUtils.isNotEmpty(firstname))
                {
                    confirmUri += "&firstname=" + URIUtils.encodeParameter(firstname);
                }

                i18nParams.put("confirmUri", new I18nizableText(confirmUri));
            }
            finally
            {
                _renderingContextHandler.setRenderingContext(currentContext);
            }
        }
        else
        {
            throw new UserManagementException("No signup page found for site " + siteName + " and language " + language, StatusError.NO_SIGNUP_PAGE);
        }

        // Add site information in the parameters.
        i18nParams.put("siteTitle", new I18nizableText(site.getTitle()));
        i18nParams.put("siteUrl", new I18nizableText(site.getUrl()));
        
        String subject = fromInvitation ? _userSignUpConfiguration.getSubjectForInvitationToSignUpEmail(i18nParams, language) : _userSignUpConfiguration.getSubjectForSignUpEmail(i18nParams, language);
        String textBody = fromInvitation ? _userSignUpConfiguration.getTextBodyForInvitationToSignUpEmail(i18nParams, language) : _userSignUpConfiguration.getTextBodyForSignUpEmail(i18nParams, language);
        String htmlBody = fromInvitation ? _userSignUpConfiguration.getHtmlBodyForInvitationToSignUpEmail(i18nParams, language) : _userSignUpConfiguration.getHtmlBodyForSignUpEmail(i18nParams, language);

        try
        {
            List<String> errorReport = new ArrayList<>();
            
            // Send the e-mail.
            SendMailHelper.newMail()
                          .withSubject(subject)
                          .withHTMLBody(htmlBody)
                          .withTextBody(textBody)
                          .withSender(from)
                          .withRecipient(email)
                          .withErrorReport(errorReport)
                          .sendMail();
            
            if (errorReport.contains(email))
            {
                throw new UserManagementException("Error sending the sign-up confirmation mail.", StatusError.MAIL_ERROR);
            }
        }
        catch (MessagingException | IOException e)
        {
            throw new UserManagementException("Error sending the sign-up confirmation mail.", StatusError.MAIL_ERROR, e);
        }
    }
    
    /**
     * Send a sign-up confirmation link by e-mail.
     * @param siteName the site name.
     * @param language the e-mail language.
     * @param user the created user
     * @throws UserManagementException if an error occurs.
     */
    protected void sendSignupValidatedMail(String siteName, String language, User user) throws UserManagementException
    {
        Site site = _siteManager.getSite(siteName);
        String from = site.getValue("site-mail-from");
        String email = user.getEmail();

        if (getLogger().isDebugEnabled())
        {
            getLogger().debug("Sending signup validation e-mail to " + email);
        }
        
        // Prepare mail.
        Map<String, I18nizableTextParameter> i18nParams = new HashMap<>();
        i18nParams.put("siteName", new I18nizableText(siteName));
        i18nParams.put("fullName", new I18nizableText(user.getFullName()));
        i18nParams.put("email", new I18nizableText(user.getEmail()));
        i18nParams.put("login", new I18nizableText(user.getIdentity().getLogin()));

        // Add site information in the parameters.
        i18nParams.put("siteTitle", new I18nizableText(site.getTitle()));
        i18nParams.put("siteUrl", new I18nizableText(site.getUrl()));

        String subject = _userSignUpConfiguration.getSubjectForSignUpValidatedEmail(i18nParams, language);
        String textBody = _userSignUpConfiguration.getTextBodyForSignUpValidatedEmail(i18nParams, language);
        String htmlBody = _userSignUpConfiguration.getHtmlBodyForSignUpValidatedEmail(i18nParams, language);

        try
        {
            // Send the e-mail.
            SendMailHelper.newMail()
                          .withSubject(subject)
                          .withHTMLBody(htmlBody)
                          .withTextBody(textBody)
                          .withSender(from)
                          .withRecipient(email)
                          .sendMail();
        }
        catch (MessagingException | IOException e)
        {
            throw new UserManagementException("Error sending the sign-up validation mail.", StatusError.MAIL_ERROR, e);
        }
    }

    /**
     * Update the sign-up request token: reset the date and set a new token.
     * @param siteName the site name.
     * @param email the user e-mail.
     * @param newToken the new token.
     * @param population The id of the population
     * @param userDirectoryId The id of the user directory of the population
     * @throws UserManagementException if an error occurs.
     */
    protected void updateTempToken(String siteName, String email, String newToken, String population, String userDirectoryId) throws UserManagementException
    {
        try (SqlSession sqlSession = getSession())
        {
            String stmtId = "UserSignupManager.updateTempToken";
            
            Map<String, Object> params = new HashMap<>();
            params.put("tempUsersTable", _tempUsersTable);
            
            Timestamp now = new Timestamp(System.currentTimeMillis());
            params.put("subscription_date", now);
            params.put("token", newToken);
            params.put("site", siteName);
            params.put("email", email);
            params.put("population", population);
            params.put("userDirectory", userDirectoryId);
            
            sqlSession.update(stmtId, params);
            sqlSession.commit();
        }
        catch (Exception e)
        {
            throw new UserManagementException("Database error while resetting the subscription for user [" + email + "]", StatusError.DATABASE_ERROR, e);
        }
    }

    /**
     * Create a user password change request in the database.
     * @param siteName the site name.
     * @param login the user login.
     * @param token the generated token.
     * @param population the population
     * @throws UserManagementException if an error occurs.
     */
    public void addPasswordToken(String siteName, String login, String token, String population) throws UserManagementException
    {
        try (SqlSession sqlSession = getSession())
        {
            String stmtId = "UserSignupManager.hasToken";
            
            Map<String, Object> params = new HashMap<>();
            params.put("pwdChangeTable", _pwdChangeTable);
            
            params.put("site", siteName);
            params.put("login", login);
            params.put("population", population);
            
            List<Object> pwdEntries = sqlSession.selectList(stmtId, params);
            
            if (pwdEntries.isEmpty())
            {
                // Insert a new token.
                stmtId = "UserSignupManager.addPasswordToken";
                params = new HashMap<>();
                params.put("pwdChangeTable", _pwdChangeTable);
                
                Timestamp now = new Timestamp(System.currentTimeMillis());
                params.put("site", siteName);
                params.put("login", login);
                params.put("request_date", now);
                params.put("token", token);
                params.put("population", population);
                
                sqlSession.insert(stmtId, params);
            }
            else
            {
                // Update the existing token.
                stmtId = "UserSignupManager.updatePasswordToken";
                params = new HashMap<>();
                params.put("pwdChangeTable", _pwdChangeTable);
                
                Timestamp now = new Timestamp(System.currentTimeMillis());
                params.put("request_date", now);
                params.put("token", token);
                params.put("site", siteName);
                params.put("login", login);
                params.put("population", population);
                
                sqlSession.update(stmtId, params);
            }
            
            // commit insert or update
            sqlSession.commit();
        }
        catch (Exception e)
        {
            throw new UserManagementException("Database error while inserting a password change token for " + login, StatusError.DATABASE_ERROR, e);
        }
    }

    /**
     * Get a temporary user from his site name and e-mail.
     * @param siteName the site name.
     * @param email The temporary user e-mail. Cannot be null.
     * @param population the population
     * @param userDirectoryId the id of the user directory of the population
     * @return the temporary user or null if not found.
     * @throws UserManagementException if an error occurs.
     */
    protected TempUser getTempUser(String siteName, String email, String population, String userDirectoryId) throws UserManagementException
    {
        return getTempUser(siteName, email, null, population, userDirectoryId);
    }
    
    /**
     * Get temporary users properties
     * @param emails the emails of temporary users
     * @param siteName the site name of temporary users
     * @return The temporary users properties
     * @throws UserManagementException if an error occurs.
     */
    @Callable
    public Map<String, Object> getTempUsersProperties(List<String> emails, String siteName) throws UserManagementException
    {
        List<Map<String, Object>> tempUsers = new ArrayList<>();
        List<String> unknownTempUsers = new ArrayList<>();
        
        for (String email : emails)
        {
            TempUser tempUser = getTempUser(siteName, email, null, null);
            if (tempUser != null)
            {
                tempUsers.add(_tempUser2json(tempUser, false, true));
            }
            else
            {
                unknownTempUsers.add(email);
            }
        }
        
        return Map.of("tempusers", tempUsers, "unknownTempusers", unknownTempUsers);
    }
    
    
    /**
     * Get the temporary users from a given site matching the search parameters
     * @param siteName the site name
     * @param searchParameters the search parameters
     * @param offset index of the start of search
     * @param limit the maximum number of results
     * @param sorts The sorters
     * @return the temporary users as JSON object
     * @throws UserManagementException if an error occurs.
     */
    @Callable
    public Map<String, Object> searchTempUsers(String siteName, Map<String, Object> searchParameters, int offset, int limit, List<Map<String, String>> sorts) throws UserManagementException
    {
        // Remove expired token from user request
        removeExpiredTokens();
        
        Map<String, Object> results = new HashMap<>();
        
        List<Map<String, Object>> tempUsers = getTempUsers(siteName, searchParameters, offset, limit, sorts).stream()
            .map(u -> _tempUser2json(u, true, false))
            .collect(Collectors.toList());
        
        int totalCount = getTotalCount(siteName, searchParameters);
        
        results.put("users", tempUsers);
        results.put("total", totalCount);
        
        return results;
    }
    
    private Map<String, Object> _tempUser2json(TempUser tempUser, boolean full, boolean withRights)
    {
        Map<String, Object> userInfos = new HashMap<>();
        
        String populationId = tempUser.getPopulation();
        userInfos.put("population", populationId);
        
        String udId = tempUser.getUserDirectoryId();
        userInfos.put("userDirectory", udId);
        
        if (full)
        {
            UserPopulation userPopulation = _userPopulationDAO.getUserPopulation(populationId);
            if (userPopulation != null)
            {
                userInfos.put("populationLabel", userPopulation.getLabel());
                
                UserDirectory userDirectory = userPopulation.getUserDirectory(udId);
                if (userDirectory != null)
                {
                    String udLabel = userDirectory.getLabel();
                    if (StringUtils.isEmpty(udLabel))
                    {
                        String udModelId = userDirectory.getUserDirectoryModelId();
                        UserDirectoryModel udModel = _userDirectoryFactory.getExtension(udModelId);
                        userInfos.put("userDirectoryLabel", udModel.getLabel());
                    }
                    else
                    {
                        userInfos.put("userDirectoryLabel", udLabel);
                    }
                }
            }
        }
        
        userInfos.put("email", tempUser.getEmail());
        userInfos.put("firstname", tempUser.getFirstname());
        userInfos.put("lastname", tempUser.getLastname());
        userInfos.put("origin", tempUser.getOrigin().name());
        userInfos.put("siteName", tempUser.getSite());
        
        Date rawSubscriptionDate = tempUser.getSubscriptionDate();
        ZonedDateTime subscriptionDate = rawSubscriptionDate.toInstant().atZone(ZoneId.systemDefault());
        ZonedDateTime expirationDate = subscriptionDate.toLocalDate().atStartOfDay(ZoneId.systemDefault()).plusDays(_userSignUpConfiguration.getTokenValidity());
        
        userInfos.put("subscriptionDate", subscriptionDate);
        userInfos.put("expirationDate", expirationDate);
        
        userInfos.put("expired", expirationDate.toLocalDate().isBefore(LocalDate.now()));
        
        if (withRights)
        {
            boolean canHandle = tempUser.getOrigin() == TempUserOrigin.INVITATION && getAllowedUserPopulationForInvitation(tempUser.getSite()).contains(tempUser.getPopulation());
            userInfos.put("canHandle", canHandle);
        }
        
        return userInfos;
    }
    
    /**
     * Verify that current user is allowed to handle invitation for a given population
     * @param siteName the site name.
     * @param populationId The population id
     * @throws UserManagementException if user is not allowed
     */
    protected void checkUserAllowedForInvitation(String siteName, String populationId) throws UserManagementException
    {
        UserIdentity currentUser = _currentUserProvider.getUser();
        
        boolean hasRight = _rightManager.hasRight(currentUser, "Web_Rights_HandleInvitations", "/cms") == RightResult.RIGHT_ALLOW
                || _rightManager.hasRight(currentUser, "Web_Rights_HandleInvitations_OwnPopulation", "/cms") == RightResult.RIGHT_ALLOW && currentUser.getPopulationId().equals(populationId);
        
        if (!hasRight)
        {
            throw new UserManagementException("User is not allowed to handle invitations for population '" + populationId + "' and site name '" + siteName + "'", StatusError.USER_NOT_ALLOWED);
        }
    }
    
    /**
     * Get the ids of user populations the current user can handle for invitation
     * @param siteName the site name
     * @return the ids of user populations handled by current users
     */
    public Set<String> getAllowedUserPopulationForInvitation(String siteName)
    {
        UserIdentity currentUser = _currentUserProvider.getUser();
        boolean canHandleAll = _rightManager.hasRight(currentUser, "Web_Rights_HandleInvitations", "/cms") == RightResult.RIGHT_ALLOW;
        
        Set<String> populationIds = _populationContextHelper.getUserPopulationsOnContexts(List.of("/sites/" + siteName, "/sites-fo/" + siteName), false);
        return populationIds.stream()
                .filter(pId -> canHandleAll || _rightManager.hasRight(currentUser, "Web_Rights_HandleInvitations_OwnPopulation", "/cms") == RightResult.RIGHT_ALLOW && currentUser.getPopulationId().equals(pId))
                .collect(Collectors.toSet());
    }
    
    /**
     * Get the temporary users from a given site matching the search parameters
     * @param siteName the site name. Can not be null
     * @param searchParameters The search parameters
     * @param offset index of the start of search
     * @param limit the maximum number of results
     * @param sorts The sorters. Can be null or empty
     * @return the temporary users
     * @throws UserManagementException if an error occurs.
     */
    public List<TempUser> getTempUsers(String siteName, Map<String, Object> searchParameters, int offset, int limit, List<Map<String, String>> sorts) throws UserManagementException
    {
        try (SqlSession sqlSession = getSession(); Connection connection = sqlSession.getConnection();)
        {
            String stmtId = "UserSignupManager.searchTempUsers";
            
            Map<String, Object> params = new HashMap<>();
            params.put("tempUsersTable", _tempUsersTable);
            params.put("databaseType", ConnectionHelper.getDatabaseType(connection));
            
            params.put("site", siteName);
            if (sorts != null && !sorts.isEmpty())
            {
                params.put("sorts", sorts);
            }
            else
            {
                // default sort by email
                params.put("sorts", List.of(Map.of("property", "email", "direction", "ASC")));
            }
            
            for (Entry<String, Object> searchParameter : searchParameters.entrySet())
            {
                String paramName = searchParameter.getKey();
                Object value = searchParameter.getValue();
                
                if (value != null && !(value instanceof String) || value instanceof String strValue && StringUtils.isNotEmpty(strValue))
                {
                    params.put(paramName, "pattern".equals(paramName) ? StringUtils.lowerCase((String) value) : value);
                }
            }
            
            return sqlSession.selectList(stmtId, params, new RowBounds(offset, limit));
        }
        catch (Exception e)
        {
            throw new UserManagementException("Database error while getting temporay users for site '" + siteName + "'", StatusError.DATABASE_ERROR, e);
        }
    }
    
    /**
     * Get the number of temporary users matching the search parameters
     * @param siteName the site name. Can not be null
     * @param searchParameters The search parameters
     * @return the total number of results
     * @throws UserManagementException if an error occurs.
     */
    public int getTotalCount(String siteName, Map<String, Object> searchParameters) throws UserManagementException
    {
        try (SqlSession session = getSession(); Connection connection = session.getConnection();)
        {
           
            Map<String, Object> params = new HashMap<>();
            params.put("tempUsersTable", _tempUsersTable);
            params.put("databaseType", ConnectionHelper.getDatabaseType(connection));
            
            params.put("site", siteName);
            
            for (Entry<String, Object> searchParameter : searchParameters.entrySet())
            {
                String paramName = searchParameter.getKey();
                Object value = searchParameter.getValue();
                
                if (value != null && !(value instanceof String) || value instanceof String strValue && StringUtils.isNotEmpty(strValue))
                {
                    params.put(paramName, value);
                }
            }
            return session.selectOne("UserSignupManager.getTotalCount", params);
        }
        catch (SQLException e)
        {
            throw new UserManagementException("Database error while getting temporay users for site '" + siteName + "'", StatusError.DATABASE_ERROR, e);
        }
    }

    /**
     * Get a temporary user from his site name, e-mail and/or token.
     * At least one of e-mail and token must be provided.
     * @param siteName the site name.
     * @param email The temporary user e-mail. Can be null.
     * @param token The temporary user token. Can be null.
     * @param population the population. Must be not null if email is not null
     * @param userDirectoryId the id of the user directory of the population. Must be not null if email is not null
     * @return the temporary user or null if not found.
     * @throws UserManagementException if an error occurs.
     */
    protected TempUser getTempUser(String siteName, String email, String token, String population, String userDirectoryId) throws UserManagementException
    {
        if (StringUtils.isEmpty(email) && StringUtils.isEmpty(token))
        {
            throw new UserManagementException("Either e-mail or token must be provided.");
        }
        
        try (SqlSession sqlSession = getSession())
        {
            // Does this email already exists
            String stmtId = "UserSignupManager.getTempUser";
            
            Map<String, Object> params = new HashMap<>();
            params.put("tempUsersTable", _tempUsersTable);
            
            params.put("site", siteName);
            if (StringUtils.isNotEmpty(email))
            {
                params.put("email", email);
                if (StringUtils.isNotEmpty(population))
                {
                    params.put("population", population);
                }
                if (StringUtils.isNotEmpty(userDirectoryId))
                {
                    params.put("userDirectory", userDirectoryId);
                }
            }
            
            if (StringUtils.isNotEmpty(token))
            {
                params.put("token", token);
            }
            
            return sqlSession.selectOne(stmtId, params);
        }
        catch (Exception e)
        {
            throw new UserManagementException("Database error while getting the request for user [" + email + "] and token [" + token + "]", StatusError.DATABASE_ERROR, e);
        }
    }

    /**
     * Remove the temporary .
     * @param siteName the site name.
     * @param email the user e-mail address.
     * @param token the request token.
     * @param population the population
     * @param userDirectoryId the id of the user directory of the population
     * @throws UserManagementException if an error occurs.
     */
    protected void removeTempUser(String siteName, String email, String token, String population, String userDirectoryId) throws UserManagementException
    {
        try (SqlSession sqlSession = getSession())
        {
            String stmtId = "UserSignupManager.removeTempUser";
            
            Map<String, Object> params = new HashMap<>();
            params.put("tempUsersTable", _tempUsersTable);
            
            params.put("site", siteName);
            params.put("email", email);
            
            if (StringUtils.isNotBlank(token))
            {
                params.put("token", token);
            }
            if (StringUtils.isNotBlank(population))
            {
                params.put("population", population);
            }
            if (StringUtils.isNotBlank(userDirectoryId))
            {
                params.put("userDirectory", userDirectoryId);
            }
            sqlSession.delete(stmtId, params);
            sqlSession.commit();
        }
        catch (Exception e)
        {
            throw new UserManagementException("Database error while removing the token of user " + email, StatusError.DATABASE_ERROR, e);
        }
    }

    /**
     * Remove the password change request.
     * @param siteName the site name.
     * @param login the user login.
     * @param token the request token.
     * @param population the population
     * @throws UserManagementException if an error occurs.
     */
    protected void removePasswordToken(String siteName, String login, String token, String population) throws UserManagementException
    {
        try (SqlSession sqlSession = getSession())
        {
            String stmtId = "UserSignupManager.removePasswordToken";
            
            Map<String, Object> params = new HashMap<>();
            params.put("pwdChangeTable", _pwdChangeTable);
            
            params.put("site", siteName);
            params.put("login", login);
            params.put("token", token);
            params.put("population", population);
            
            sqlSession.delete(stmtId, params);
            sqlSession.commit();
        }
        catch (Exception e)
        {
            throw new UserManagementException("Database error while removing the token of user " + login, StatusError.DATABASE_ERROR, e);
        }
    }

    /**
     * Send a sign-up confirmation link by e-mail.
     * @param siteName the site name.
     * @param language the e-mail language.
     * @param user the user object.
     * @param token the generated token.
     * @throws UserManagementException if an error occurs.
     */
    protected void sendResetPasswordMail(String siteName, String language, User user, String token) throws UserManagementException
    {
        String login = user.getIdentity().getLogin();
        String population = user.getIdentity().getPopulationId();

        if (getLogger().isDebugEnabled())
        {
            getLogger().debug("Sending reset password e-mail to " + login);
        }

        Site site = _siteManager.getSite(siteName);
        String from = site.getValue("site-mail-from");

        // Prepare mail
        Map<String, I18nizableTextParameter> i18nParams = new HashMap<>();
        i18nParams.put("siteName", new I18nizableText(siteName));
        i18nParams.put("login", new I18nizableText(login));
        i18nParams.put("email", new I18nizableText(user.getEmail()));
        i18nParams.put("fullName", new I18nizableText(user.getFullName()));
        i18nParams.put("token", new I18nizableText(token));

        Page passwordPage = getPwdChangePage(siteName, language);
        if (passwordPage != null)
        {
            // Compute the confirmation URI and add it to the parameters.
            String confirmUri = getResetPasswordUri(passwordPage, login, population, token, true);
            i18nParams.put("confirmUri", new I18nizableText(confirmUri));
        }
        else
        {
            throw new UserManagementException("No password change page found for site " + siteName + " and language " + language, StatusError.NO_PASSWORD_CHANGE_PAGE);
        }

        // Add site information in the parameters.
        i18nParams.put("siteTitle", new I18nizableText(site.getTitle()));
        i18nParams.put("siteUrl", new I18nizableText(site.getUrl()));

        String subject = _userSignUpConfiguration.getSubjectForResetPwdEmail(i18nParams, language);
        String textBody = _userSignUpConfiguration.getTextBodyForResetPwdEmail(i18nParams, language);
        String htmlBody = _userSignUpConfiguration.getHtmlBodyForResetPwdEmail(i18nParams, language);

        try
        {
            // Send the e-mail.
            SendMailHelper.newMail()
                          .withSubject(subject)
                          .withHTMLBody(htmlBody)
                          .withTextBody(textBody)
                          .withSender(from)
                          .withRecipient(user.getEmail())
                          .sendMail();
        }
        catch (MessagingException | IOException e)
        {
            throw new UserManagementException("Error sending a password reset e-mail.", StatusError.MAIL_ERROR, e);
        }
    }
    
    /**
     * Get the URI to reset a password
     * @param passwordPage The passwodr page. Can not be null.
     * @param login the user login
     * @param population the user population
     * @param token the generated token
     * @param absolute true to get absolute uri
     * @return the computed uri
     */
    public String getResetPasswordUri(Page passwordPage, String login, String population, String token, boolean absolute)
    {
        String encodedLogin = URIUtils.encodeParameter(login);
        String encodedPopulation = URIUtils.encodeParameter(population);

        // Compute the confirmation URI and add it to the parameters.
        String confirmUri = ResolveURIComponent.resolve("page", passwordPage.getId(), false, absolute);
        return confirmUri + "?login=" + encodedLogin + "&population=" + encodedPopulation + "&token=" + token;
    }

    /**
     * Bean representing a user sign-up request.
     */
    public static class TempUser
    {
        /** The site name. */
        protected String _site;
        
        /** The user e-mail. */
        protected String _email;

        /** The user subscription date. */
        protected Date _subscriptionDate;

        /** The request token. */
        protected String _token;

        /** The id of the population */
        protected String _population;

        /** The id of the user directory of the population */
        protected String _userDirectoryId;
        
        /** The user last name */
        protected String _lastname;
        
        /** The user first name */
        protected String _firstname;
        
        /** The user origin */
        protected TempUserOrigin _origin;
        
        /**
         * Enumeration for temporary user origin
         *
         */
        public enum TempUserOrigin 
        {
            /** When the signup request comes from an invitation */
            INVITATION,
            /** When the signup request is an user request  */
            USER_REQUEST,
            /** When the origin of signup request is unknown */
            UNKNWON
        }

        /**
         * Constructor.
         * @param site the site
         * @param email the user's email
         * @param subscriptionDate the date of subscription
         * @param token the user's token
         * @param population The id of the population
         * @param userDirectoryId The id of the user directory of the population
         * @param lastname the user's lastname
         * @param firstname the user's firstname
         * @param origin the origin of this temp user
         */
        public TempUser(String site, String email, Date subscriptionDate, String token, String population, String userDirectoryId, String lastname, String firstname, String origin)
        {
            this._site = site;
            this._email = email;
            this._subscriptionDate = subscriptionDate;
            this._token = token;
            this._population = population;
            this._userDirectoryId = userDirectoryId;
            this._lastname = lastname;
            this._firstname = firstname;
            this._origin = StringUtils.isNotBlank(origin) ? TempUserOrigin.valueOf(origin) : TempUserOrigin.UNKNWON;
        }
        /**
         * Get the site.
         * @return the site
         */
        public String getSite()
        {
            return _site;
        }
        /**
         * Set the site.
         * @param site the site to set
         */
        public void setSite(String site)
        {
            this._site = site;
        }
        /**
         * Get the email.
         * @return _the email
         */
        public String getEmail()
        {
            return _email;
        }
        /**
         * Set the email.
         * @param email the email to set
         */
        public void setEmail(String email)
        {
            this._email = email;
        }
        /**
         * Get the subscriptionDate.
         * @return _the subscriptionDate
         */
        public Date getSubscriptionDate()
        {
            return _subscriptionDate;
        }
        /**
         * Set the subscriptionDate.
         * @param subscriptionDate the subscriptionDate to set
         */
        public void setSubscriptionDate(Date subscriptionDate)
        {
            this._subscriptionDate = subscriptionDate;
        }
        /**
         * Get the token.
         * @return _the token
         */
        public String getToken()
        {
            return _token;
        }
        /**
         * Set the token.
         * @param token the token to set
         */
        public void setToken(String token)
        {
            this._token = token;
        }
        /**
         * Get the population.
         * @return the population
         */
        public String getPopulation()
        {
            return _population;
        }
        /**
         * Set the population.
         * @param population the population to set
         */
        public void setPopulation(String population)
        {
            this._population = population;
        }
        /**
         * Get the user directory id.
         * @return the user directory id
         */
        public String getUserDirectoryId()
        {
            return _userDirectoryId;
        }
        /**
         * Set the user directory index.
         * @param userDirectoryId the user directory id to set
         */
        public void setUserDirectoryIndex(String userDirectoryId)
        {
            this._userDirectoryId = userDirectoryId;
        }
        
        /**
         * Get the user firstname
         * @return the user firstname
         */
        public String getFirstname()
        {
            return _firstname;
        }
        
        /**
         * Set the user firstname
         * @param firstname the user firstname
         */
        public void setFirstname(String firstname)
        {
            _firstname = firstname;
        }
        
        /**
         * Get the user firstname
         * @return the user firstname
         */
        public String getLastname()
        {
            return _lastname;
        }
        
        /**
         * Set the user lastname
         * @param lastname the user lastname
         */
        public void setLastname(String lastname)
        {
            _lastname = lastname;
        }
        
        /**
         * Return the temp user origin
         * @return true the temp user origin
         */
        public TempUserOrigin getOrigin()
        {
            return _origin;
        }
        
        /**
         * Set the origin of this temporary user
         * @param origin the origin
         */
        public void setOrigin(TempUserOrigin origin)
        {
            _origin = origin;
        }
    }

}