/** POST /account -> update the current user information. */
 @RequestMapping(
     value = "/account",
     method = RequestMethod.POST,
     produces = MediaType.APPLICATION_JSON_VALUE)
 @Timed
 public ResponseEntity<String> saveAccount(@RequestBody UserDTO userDTO) {
   Optional<User> existingUser = userRepository.findOneByEmail(userDTO.getEmail());
   if (existingUser.isPresent()
       && (!existingUser.get().getLogin().equalsIgnoreCase(userDTO.getLogin()))) {
     return ResponseEntity.badRequest()
         .headers(
             HeaderUtil.createFailureAlert(
                 "user-management", "emailexists", "Email already in use"))
         .body(null);
   }
   return userRepository
       .findOneByLogin(SecurityUtils.getCurrentUser().getUsername())
       .map(
           u -> {
             userService.updateUserInformation(
                 userDTO.getFirstName(),
                 userDTO.getLastName(),
                 userDTO.getEmail(),
                 userDTO.getLangKey());
             return new ResponseEntity<String>(HttpStatus.OK);
           })
       .orElseGet(() -> new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR));
 }
 public void changePassword(String password) {
   userRepository
       .findOneByLogin(SecurityUtils.getCurrentUserLogin())
       .ifPresent(
           u -> {
             String encryptedPassword = passwordEncoder.encode(password);
             u.setPassword(encryptedPassword);
             userRepository.save(u);
             log.debug("Changed password for User: {}", u);
           });
 }
 /** GET /account/sessions -> get the current open sessions. */
 @RequestMapping(
     value = "/account/sessions",
     method = RequestMethod.GET,
     produces = MediaType.APPLICATION_JSON_VALUE)
 @Timed
 public ResponseEntity<List<PersistentToken>> getCurrentSessions() {
   return userRepository
       .findOneByLogin(SecurityUtils.getCurrentLogin())
       .map(
           user -> new ResponseEntity<>(persistentTokenRepository.findByUser(user), HttpStatus.OK))
       .orElse(new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR));
 }
 public void updateUserInformation(
     String firstName, String lastName, String email, String langKey) {
   userRepository
       .findOneByLogin(SecurityUtils.getCurrentLogin())
       .ifPresent(
           u -> {
             u.setFirstName(firstName);
             u.setLastName(lastName);
             u.setEmail(email);
             u.setLangKey(langKey);
             userRepository.save(u);
             log.debug("Changed Information for User: {}", u);
           });
 }
 /**
  * DELETE /account/sessions?series={series} -> invalidate an existing session.
  *
  * <p>- You can only delete your own sessions, not any other user's session - If you delete one of
  * your existing sessions, and that you are currently logged in on that session, you will still be
  * able to use that session, until you quit your browser: it does not work in real time (there is
  * no API for that), it only removes the "remember me" cookie - This is also true if you
  * invalidate your current session: you will still be able to use it until you close your browser
  * or that the session times out. But automatic login (the "remember me" cookie) will not work
  * anymore. There is an API to invalidate the current session, but there is no API to check which
  * session uses which cookie.
  */
 @RequestMapping(value = "/account/sessions/{series}", method = RequestMethod.DELETE)
 @Timed
 public void invalidateSession(@PathVariable String series) throws UnsupportedEncodingException {
   String decodedSeries = URLDecoder.decode(series, "UTF-8");
   userRepository
       .findOneByLogin(SecurityUtils.getCurrentLogin())
       .ifPresent(
           u -> {
             persistentTokenRepository
                 .findByUser(u)
                 .stream()
                 .filter(
                     persistentToken ->
                         StringUtils.equals(persistentToken.getSeries(), decodedSeries))
                 .findAny()
                 .ifPresent(t -> persistentTokenRepository.delete(decodedSeries));
           });
 }
 /** POST /account -> update the current user information. */
 @RequestMapping(
     value = "/account",
     method = RequestMethod.POST,
     produces = MediaType.APPLICATION_JSON_VALUE)
 @Timed
 public ResponseEntity<String> saveAccount(@RequestBody UserDTO userDTO) {
   return userRepository
       .findOneByLogin(userDTO.getLogin())
       .filter(u -> u.getLogin().equals(SecurityUtils.getCurrentLogin()))
       .map(
           u -> {
             userService.updateUserInformation(
                 userDTO.getFirstName(),
                 userDTO.getLastName(),
                 userDTO.getEmail(),
                 userDTO.getLangKey());
             return new ResponseEntity<String>(HttpStatus.OK);
           })
       .orElseGet(() -> new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR));
 }
 @Transactional(readOnly = true)
 public User getUserWithAuthorities() {
   User user = userRepository.findOneByLogin(SecurityUtils.getCurrentUserLogin()).get();
   user.getAuthorities().size(); // eagerly load the association
   return user;
 }