public MongoRememberMeToken(final PersistentRememberMeToken persistentRememberMeToken) { this(persistentRememberMeToken.getUsername(), persistentRememberMeToken.getSeries(), persistentRememberMeToken.getTokenValue(), persistentRememberMeToken.getDate(), null); }
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); }
@Override public void createNewToken(PersistentRememberMeToken token) { Long sessionId = Long.valueOf(token.getSeries()); Long userId = Long.valueOf(token.getUsername()); sessionService.createSession(sessionId, userId, token.getTokenValue()); }
/** * Stores token in cache. * @param token Token to be stored * @see CachedRememberMeTokenInfo */ private void cacheToken(PersistentRememberMeToken token) { if (tokenCache.size() >= TOKEN_CACHE_MAX_SIZE) { validateTokenCache(); } CachedRememberMeTokenInfo tokenWrapper = new CachedRememberMeTokenInfo(token.getTokenValue(), System.currentTimeMillis()); tokenCache.put(token.getSeries(), tokenWrapper); }
@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()); }
/** * Find and check found persistent remember me token with presented token * from cookie. * * @param presentedSeries presented series from cookie * @param presentedToken presented token from cookie * @return {@code true} if token not exists in database or presented token equals to persistent token, * {@code false} if token exists in database and it doesn't equals to presented token */ public boolean equalWithPersistentToken(String presentedSeries, String presentedToken) { PersistentRememberMeToken token = persistentTokenRepository.getTokenForSeries(presentedSeries); if (token != null) { String persistentToken = token.getTokenValue(); if (!ObjectUtils.equals(presentedToken, persistentToken)) { String logErrorMessage = composeErrorMessageForNotEqualTokens( token.getUsername(), presentedToken, presentedSeries, persistentToken); LOGGER.error(logErrorMessage); return false; } } return true; }
public PersistentRememberMeToken toPersistentRememberMeToken() { return new PersistentRememberMeToken(this.username, this.series, this.tokenValue, this.date); } }
details = getUserDetailsService().loadUserByUsername(token.getUsername()); rewriteCookie(token, request, response); } else { tokenCache.remove(token.getSeries()); throw ex;
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);
public synchronized void createNewToken(PersistentRememberMeToken token) { PersistentRememberMeToken current = seriesTokens.get(token.getSeries()); if (current != null) { throw new DataIntegrityViolationException("Series Id '" + token.getSeries() + "' already exists!"); } seriesTokens.put(token.getSeries(), token); }
public synchronized void removeUserTokens(String username) { Iterator<String> series = seriesTokens.keySet().iterator(); while (series.hasNext()) { String seriesId = series.next(); PersistentRememberMeToken token = seriesTokens.get(seriesId); if (username.equals(token.getUsername())) { series.remove(); } } } }
/** * Sets valid cookie to response * Needed for possibility to test. */ @VisibleForTesting void rewriteCookie(PersistentRememberMeToken token, HttpServletRequest request, HttpServletResponse response) { setCookie(new String[] {token.getSeries(), token.getTokenValue()}, getTokenValiditySeconds(), request, response); }
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);
/** * The method provides the functionality to store a new token in the token repository * @param token The token that will be stored in the token repository */ @Override public synchronized void createNewToken(PersistentRememberMeToken token) { PersistentRememberMeToken current = this.seriesTokens.get(token.getSeries()); if(current != null) { throw new DataIntegrityViolationException("Series Id \'" + token.getSeries() + "\' already exists!"); } else { this.seriesTokens.put(token.getSeries(), token); saveTokens(); } }
/** * Remove a user token from the repository * @param username The token that matches this user name will be removed */ @Override public synchronized void removeUserTokens(String username) { Iterator series = this.seriesTokens.keySet().iterator(); while(series.hasNext()) { String seriesId = (String)series.next(); PersistentRememberMeToken token = this.seriesTokens.get(seriesId); if(username.equals(token.getUsername())) { series.remove(); } } saveTokens(); }
public SessionToken(PersistentRememberMeToken persistentRememberMeToken) { this.username = persistentRememberMeToken.getUsername(); this.series = persistentRememberMeToken.getSeries(); this.tokenValue = persistentRememberMeToken.getTokenValue(); this.date = persistentRememberMeToken.getDate(); }
private void addCookie(PersistentRememberMeToken token, HttpServletRequest request, HttpServletResponse response) { setCookie(new String[] { token.getSeries(), token.getTokenValue() }, getTokenValiditySeconds(), request, response); }
/** * 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)); }
/** * The method provides the functionality to store a new token in the token repository * * @param token The token that will be stored in the token repository */ @Override public void createNewToken(PersistentRememberMeToken token) { try { mongoOperations.insert(new SessionToken(token)); } catch (DataIntegrityViolationException ex) { LOGGER.error(ex.getMessage()); throw new DataIntegrityViolationException("Series Id \'" + token.getSeries() + "\' already exists!"); } }