public PersistentRememberMeToken toPersistentRememberMeToken() { return new PersistentRememberMeToken(this.username, this.series, this.tokenValue, this.date); } }
public PersistentRememberMeToken mapRow(ResultSet rs, int rowNum) throws SQLException { return new PersistentRememberMeToken(rs.getString(1), rs .getString(2), rs.getString(3), rs.getTimestamp(4)); } }, seriesId);
public synchronized void updateToken(String series, String tokenValue, Date lastUsed) { PersistentRememberMeToken token = getTokenForSeries(series); PersistentRememberMeToken newToken = new PersistentRememberMeToken( token.getUsername(), series, tokenValue, new Date()); // Store it, overwriting the existing one. seriesTokens.put(series, newToken); }
/** * Updates a specific token with a new values to a specific token * @param series The token that will be updated * @param tokenValue The new token value * @param lastUsed Date for when it was last used */ @Override public synchronized void updateToken(String series, String tokenValue, Date lastUsed) { PersistentRememberMeToken token = this.getTokenForSeries(series); PersistentRememberMeToken newToken = new PersistentRememberMeToken(token.getUsername(), series, tokenValue, new Date()); this.seriesTokens.put(series, newToken); saveTokens(); }
private PersistentRememberMeToken toPersistentRememberMeToken(Session session) { String username = String.valueOf(session.getUserId()); String series = String.valueOf(session.getId()); LocalDateTime lastUsedAt = Optional.ofNullable(session.getLastUsedAt()).orElseGet(session::getIssuedAt); return new PersistentRememberMeToken( username, series, session.getToken(), toDate(lastUsedAt)); }
SessionTokenList tokens = (SessionTokenList) jaxbUnmarshaller.unmarshal(file); for(SessionToken token : tokens){ PersistentRememberMeToken persistentRememberMeToken = new PersistentRememberMeToken(token.getUsername(), token.getSeries(), token.getTokenValue(), token.getDate()); seriesTokens.put(persistentRememberMeToken.getSeries(), persistentRememberMeToken);
/** * Creates a new persistent login token with a new series number, stores the data in * the persistent token repository and adds the corresponding cookie to the response. * */ protected void onLoginSuccess(HttpServletRequest request, HttpServletResponse response, Authentication successfulAuthentication) { String username = successfulAuthentication.getName(); logger.debug("Creating new persistent login for user " + username); PersistentRememberMeToken persistentToken = new PersistentRememberMeToken( username, generateSeriesData(), generateTokenData(), new Date()); try { tokenRepository.createNewToken(persistentToken); addCookie(persistentToken, request, response); } catch (Exception e) { logger.error("Failed to save persistent token ", e); } }
default PersistentRememberMeToken getTokenForSeries(String seriesId) { List<PersistentLogins> logins = this.findBySeries(seriesId); if (logins.isEmpty()) { return null; } PersistentLogins login = logins.get(0); return new PersistentRememberMeToken(login.getUsername(), login.getSeries(), login.getToken(), login.getLastUsed()); }
private void createTokenJob(CountDownLatch lock, AtomicInteger successCount, AtomicInteger exceptionCount, String username) { try { sessionTokenRepository.createNewToken(new PersistentRememberMeToken(username, "s1", "t2", new Date())); successCount.incrementAndGet(); } catch (DataIntegrityViolationException ex) { exceptionCount.incrementAndGet(); } finally { lock.countDown(); } } }
/** * The method provides the functionality to update the token with a new username. The token * will be identified with the old username and upon found, the username will be updated to the * new provided username value * @param oldUsername The old username. It is used to identify the token * @param newUsername The new username. It will replace the old username */ public synchronized void updateToken(String oldUsername, String newUsername) { final List<PersistentRememberMeToken> tokens = new LinkedList<PersistentRememberMeToken>(); for(PersistentRememberMeToken token : seriesTokens.values()){ if(token.getUsername().equalsIgnoreCase(oldUsername)){ PersistentRememberMeToken newToken = new PersistentRememberMeToken(newUsername, token.getSeries(), token.getTokenValue(), token.getDate()); tokens.add(newToken); } } for(PersistentRememberMeToken token : tokens){ seriesTokens.put(token.getSeries(), token); } saveTokens(); }
@Test public void testRemoveUserTokens() { sessionTokenRepository.createNewToken(new PersistentRememberMeToken("abdullah", "s1", "t1", new Date())); sessionTokenRepository.createNewToken(new PersistentRememberMeToken("abdullah", "s2", "t2", new Date())); sessionTokenRepository.createNewToken(new PersistentRememberMeToken("farida", "s3", "t3", new Date())); sessionTokenRepository.createNewToken(new PersistentRememberMeToken("abdullah", "s4", "t4", new Date())); sessionTokenRepository.createNewToken(new PersistentRememberMeToken("abdullah", "s5", "t5", new Date())); sessionTokenRepository.removeUserTokens("abdullah"); long sessionToken = mongoOperations.count(new Query(), "sessionToken"); assertThat(sessionToken).isEqualTo(1); }
@Override public PersistentRememberMeToken getTokenForSeries(String seriesId) { RememberMeToken token = this.rememberMeTokenRepository.findBySeries(seriesId); if (token == null){ return null; } return new PersistentRememberMeToken(token.getUsername(), token.getSeries(), token.getTokenValue(), token.getDate()); }
@Test public void testCreateNewToken_CreatesAToken() { String series = "1uyasddf32"; PersistentRememberMeToken rememberMeToken = new PersistentRememberMeToken("abdullah", series, "134xsdf32", new Date()); sessionTokenRepository.createNewToken(rememberMeToken); PersistentRememberMeToken rememberMeTokenFromDb = sessionTokenRepository.getTokenForSeries(series); assertThat(rememberMeTokenFromDb).isEqualToComparingFieldByField(rememberMeToken); }
@Test public void testUpdateByUsername() { String series = "someSeries"; PersistentRememberMeToken rememberMeToken = new PersistentRememberMeToken("abdullah", series, "oldToken", new Date()); sessionTokenRepository.createNewToken(rememberMeToken); sessionTokenRepository.updateToken("abdullah", "farida"); PersistentRememberMeToken tokenFromDb = sessionTokenRepository.getTokenForSeries(series); assertThat(tokenFromDb.getUsername()).isEqualTo("farida"); assertThat(tokenFromDb).isEqualToIgnoringGivenFields(rememberMeToken, "username"); }
@Test public void testUpdateBySeries() { String series = "someSeries"; PersistentRememberMeToken rememberMeToken = new PersistentRememberMeToken("abdullah", series, "oldToken", new Date()); sessionTokenRepository.createNewToken(rememberMeToken); sessionTokenRepository.updateToken(series, "newToken", Date.from(Instant.parse("2010-01-01T10:00:00z"))); PersistentRememberMeToken tokenFromDb = sessionTokenRepository.getTokenForSeries(series); assertThat(tokenFromDb.getTokenValue()).isEqualTo("newToken"); // Note, the `lastUsed` parameter to updateToken is ignored, and a `new Date()` // object is used instead, to be fully compliant with current file-based implementation. assertThat(tokenFromDb.getDate()).isEqualToIgnoringMinutes(new Date()); }
@Test public void testCreateNewToken_AlreadyExists_ThrowsException() { String series = "1uyasddf32"; PersistentRememberMeToken rememberMeToken = new PersistentRememberMeToken("abdullah", series, "134xsdf32", new Date()); sessionTokenRepository.createNewToken(rememberMeToken); try { sessionTokenRepository.createNewToken(rememberMeToken); fail("should throws exception"); } catch (DataIntegrityViolationException ex) { // Keeping the same message format of the file-based implementation for full compliance. assertThat(ex.getMessage()).isEqualTo("Series Id '1uyasddf32' already exists!"); } }
PersistentRememberMeToken newToken = new PersistentRememberMeToken( token.getUsername(), token.getSeries(), generateTokenData(), new Date());