EDIT

import java.util.Optional;

import java.util.stream.Collectors;

import org.apache.log4j.Logger;

/**

 * @author a.kohlbecker

 * @since Nov 18, 2021

 */

    public static final int TOKEN_LENGTH = 50;

    protected static Logger logger = Logger.getLogger(AbstractRequestTokenStore.class);

    @Override

        clearExpiredTokens();

        String randomToken = generateRandomToken();

        int tokenLifetimeMinutes = getTokenLifetimeMinutes();

        tokenList.put(token.getToken(), token);

        return token;

    }

    }

    @Override

        clearExpiredTokens();

        T resetRequest = tokenList.get(token);

        if(isEligibleResetRequest(resetRequest)) {

 */

public class AccountCreationRequest extends AbstractRequestToken {

    private String userEmail;

        super();

        this.userEmail = userEmail;

        this.token = token;

        this.setExpiryDate(expireInMinutes);

    }

    public String getUserEmail() {

        return userEmail;

    }

}

import org.springframework.stereotype.Component;

import eu.etaxonomy.cdm.api.service.IUserService;

/**

 * @author a.kohlbecker

 * @since Nov 3, 2021

 */

@Component

    @Autowired

    private IUserService userService;

    @Override

        return token;

    }

import java.util.Optional;

/**

 * @author a.kohlbecker

 * @since Nov 3, 2021

 */

    public static final int TOKEN_LIFETIME_MINUTES_DEFAULT = 60 * 6;

    /**

     * Removes the corresponding <code>AbstractRequestToken</code> from the

     * @return the valid <code>AbstractRequestToken</code> or an empty

     *         <code>Optional</code>

     */

    public void setTokenLifetimeMinutes(int tokenLifetimeMinutes);

}

 * @since Nov 3, 2021

 */

@Component

    @Override

        return token;

    }

    @Autowired

    @Qualifier("accountCreationRequestTokenStore")

    @Override

    @Async

        if(logger.isTraceEnabled()) {

            logger.trace("emailAccountRegistrationConfirmation() trying to aquire from rate limiter [rate: " + emailResetToken_rateLimiter.getRate() + ", timeout: " + getRateLimiterTimeout().toMillis() + "ms]");

            logger.trace("emailAccountRegistrationConfirmation() allowed by rate limiter");

            try {

                emailAddressValidAndUnused(emailAddress);

                String passwordRequestFormUrl = String.format(accountCreationRequestFormUrlTemplate, resetRequest.getToken());

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

                additionalValues.put("linkUrl", passwordRequestFormUrl);

                        UserAccountEmailTemplates.REGISTRATION_REQUEST_EMAIL_SUBJECT_TEMPLATE,

                        UserAccountEmailTemplates.REGISTRATION_REQUEST_EMAIL_BODY_TEMPLATE, additionalValues);

                return new AsyncResult<Boolean>(true);

            } catch (MailException e) {

                throw e;

    @Override

    @Async

    @Transactional(readOnly = false)

            throws MailException, AccountSelfManagementException, AddressException {

        if (resetPassword_rateLimiter.tryAcquire(getRateLimiterTimeout())) {

            if (creationRequest.isPresent()) {

                try {

                    // check again if the email address is still unused

                    emailAddressValidAndUnused(creationRequest.get().getUserEmail());

                        throw new AccountSelfManagementException(USER_NAME_EXISTS_MSG);

                    }

                    userDao.saveOrUpdate(newUser);

                    accountRegistrationTokenStore.remove(token);

                            UserAccountEmailTemplates.REGISTRATION_SUCCESS_EMAIL_SUBJECT_TEMPLATE,

                            UserAccountEmailTemplates.REGISTRATION_SUCCESS_EMAIL_BODY_TEMPLATE, null);

                    return new AsyncResult<Boolean>(true);

                } catch (DataAccessException e) {

                    logger.error(message, e);

                    throw new AccountSelfManagementException(message);

                }

     * @param userEmail

     *  The TO-address

     * @param userName

     * @param subjectTemplate

     *  A {@link StringSubstitutor} template for the email subject

     * @param bodyTemplate

        if(supportEmailAddress != null) {

            additionalValuesMap.put("supportEmailAddress", supportEmailAddress);

        }

        additionalValuesMap.put("dataBase", dataSourceBeanId);

        StringSubstitutor substitutor = new StringSubstitutor(additionalValuesMap);

     * @throws AccountSelfManagementException

     *             in case the user name is already being used.

     */

            String passwordRequestFormUrlTemplate)

            throws MailException, AddressException, AccountSelfManagementException;

     *

     * @param token

     *            the token string

     * @param givenName

     *            The new password to set - <b>required</b>

     * @param familyName

     *             {@link AccountCreationRequest} identified by the

     *             <code>token</code> not valid

     */

    boolean userNameExists(String userName);

    @Autowired

    @Qualifier("passwordResetTokenStore")

    /**

     * Create a request token and send it to the user via email.

            logger.trace("emailResetToken allowed by rate limiter");

            try {

                User user = findUser(userNameOrEmail);

                String passwordRequestFormUrl = String.format(passwordRequestFormUrlTemplate, resetRequest.getToken());

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

                additionalValues.put("linkUrl", passwordRequestFormUrl);

       if (resetPassword_rateLimiter.tryAcquire(getRateLimiterTimeout())) {

           if (resetRequest.isPresent()) {

               try {

                   UserDetails user = userService.loadUserByUsername(resetRequest.get().getUserName());

    private static final String USER_NAME = "dummy";

    @SpringBeanByName

    private User testUser;

    @Test

    public void testTokenStillValid() {

        assertTrue(passwordResetTokenStore.isEligibleToken(token));

        assertTrue(resetRequest.isPresent());

        assertEquals(USER_NAME, resetRequest.get().getUserName());

        assertEquals(USER_EMAIL, resetRequest.get().getUserEmail());

    @Test

    public void testTokenExpired() {

        passwordResetTokenStore.setTokenLifetimeMinutes(-10);

        assertFalse(passwordResetTokenStore.isEligibleToken(token));

        assertTrue(!resetRequest.isPresent());

    }

    public void testTokenUnknown() {

        String unknownToken = "un-known-token";

        assertFalse(passwordResetTokenStore.isEligibleToken(unknownToken));

        assertTrue(!resetRequest.isPresent());

    }

    public void testTokenNull() {

        String nullToken = null;

        assertFalse(passwordResetTokenStore.isEligibleToken(nullToken));

        assertTrue(!resetRequest.isPresent());

    }

    @Test

    public void testTokenRemove() {

        assertTrue(passwordResetTokenStore.isEligibleToken(token));

        assertTrue(resetRequest.isPresent());

        passwordResetTokenStore.remove(token);

        assertFalse("Expecing false since the token has been removed", resetRequest.isPresent());

    }

    private IAccountRegistrationService accountRegistrationService;

    @SpringBeanByName

    @SpringBeanByType

    private JavaMailSender emailSender;

        createRequestTokenSendSignal = new CountDownLatch(1);

        accountCreatedSignal = new CountDownLatch(1);

        emailResetFuture.addCallback(

                requestSuccessVal -> {

                    createRequestTokenSendSignal.countDown();

        assertEquals(AbstractRequestTokenStore.TOKEN_LENGTH + 17, m.group(1).length());

        // -- change password

        createAccountFuture.addCallback(requestSuccessVal -> {

            accountCreatedSignal.countDown();

        }, futureException -> {

        createRequestTokenSendSignal = new CountDownLatch(1);

        accountRegistrationService.setRateLimiterTimeout(Duration.ofMillis(1)); // as should as possible to allow the fist call to be successful (with 1ns the fist call fails!)

        emailResetFuture.addCallback(

                requestSuccessVal -> {

                    createRequestTokenSendSignal.countDown();

        accountCreatedSignal = new CountDownLatch(1);

        // -- change password

        resetPasswordFuture.addCallback(requestSuccessVal -> {

            accountCreatedSignal.countDown();

        }, futureException -> {

        createRequestTokenSendSignal = new CountDownLatch(1);

        emailResetFuture.addCallback(

                requestSuccessVal -> {

                    createRequestTokenSendSignal.countDown();

        // -- wait for passwordResetService.emailResetToken() to complete

        createRequestTokenSendSignal.await();

        assertNotNull(assyncError);

        assertEquals(AccountSelfManagementException.class, assyncError.getClass());

        assertEquals(AccountRegistrationService.USER_NAME_EXISTS_MSG, assyncError.getMessage());

    private IPasswordResetService passwordResetService;

    @SpringBeanByName

    @SpringBeanByType

    private JavaMailSender emailSender;