generator-jhipster 8.0.0-beta.2 → 8.0.0-rc.1

package/dist/generators/server/templates/src/main/java/_package_/web/rest/AccountResource.java.ejs

@@ -0,0 +1,347 @@
+<%#
+ Copyright 2013-2023 the original author or authors from the JHipster project.
+
+ This file is part of the JHipster project, see https://www.jhipster.tech/
+ for more information.
+
+ 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
+
+      https://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 <%= packageName %>.web.rest;
+
+  <%_ if (authenticationTypeSession && !reactive) { _%>
+import <%= packageName %>.domain.PersistentToken;
+import <%= packageName %>.repository.PersistentTokenRepository;
+  <%_ } _%>
+  <%_ if (!reactive) { _%>
+import <%= user.entityAbsoluteClass %>;
+  <%_ } _%>
+import <%= packageName %>.repository.UserRepository;
+import <%= packageName %>.security.SecurityUtils;
+import <%= packageName %>.service.MailService;
+import <%= packageName %>.service.UserService;
+import <%= packageName %>.service.dto.PasswordChangeDTO;
+import <%= packageName %>.service.dto.<%= user.adminUserDto %>;
+import <%= packageName %>.web.rest.errors.*;
+import <%= packageName %>.web.rest.vm.KeyAndPasswordVM;
+import <%= packageName %>.web.rest.vm.ManagedUserVM;
+
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.http.HttpStatus;
+import org.springframework.web.bind.annotation.*;
+  <%_ if (reactive) { _%>
+import org.springframework.web.server.ServerWebExchange;
+import reactor.core.publisher.Mono;
+  <%_ } _%>
+
+  <%_ if (!reactive && !authenticationTypeJwt) { _%>
+import jakarta.servlet.http.HttpServletRequest;
+  <%_ } _%>
+import jakarta.validation.Valid;
+  <%_ if (authenticationTypeSession && !reactive) { _%>
+import java.nio.charset.StandardCharsets;
+import java.net.URLDecoder;
+  <%_ } _%>
+  <%_ if (reactive) { _%>
+import java.security.Principal;
+import java.util.Objects;
+  <%_ } _%>
+  <%_ if (!reactive) { _%>
+import java.util.*;
+  <%_ } _%>
+
+/**
+ * REST controller for managing the current user's account.
+ */
+@RestController
+@RequestMapping("/api")
+public class AccountResource {
+
+    private static class AccountResourceException extends RuntimeException {
+        private AccountResourceException(String message) {
+            super(message);
+        }
+    }
+
+    private final Logger log = LoggerFactory.getLogger(AccountResource.class);
+
+    private final UserRepository userRepository;
+
+    private final UserService userService;
+
+    private final MailService mailService;
+  <%_ if (authenticationTypeSession && !reactive) { _%>
+
+    private final PersistentTokenRepository persistentTokenRepository;
+  <%_ } _%>
+
+    public AccountResource(UserRepository userRepository, UserService userService, MailService mailService<% if (authenticationTypeSession && !reactive) { %>, PersistentTokenRepository persistentTokenRepository<% } %>) {
+
+        this.userRepository = userRepository;
+        this.userService = userService;
+        this.mailService = mailService;
+  <%_ if (authenticationTypeSession && !reactive) { _%>
+        this.persistentTokenRepository = persistentTokenRepository;
+  <%_ } _%>
+    }
+
+    /**
+     * {@code POST  /register} : register the user.
+     *
+     * @param managedUserVM the managed user View Model.
+     * @throws InvalidPasswordException {@code 400 (Bad Request)} if the password is incorrect.
+     * @throws EmailAlreadyUsedException {@code 400 (Bad Request)} if the email is already used.
+     * @throws LoginAlreadyUsedException {@code 400 (Bad Request)} if the login is already used.
+     */
+    @PostMapping("/register")
+    @ResponseStatus(HttpStatus.CREATED)
+    public <% if (reactive) { %>Mono<Void><% } else { %>void<% } %> registerAccount(@Valid @RequestBody ManagedUserVM managedUserVM) {
+        if (isPasswordLengthInvalid(managedUserVM.getPassword())) {
+            throw new InvalidPasswordException();
+        }
+  <%_ if (reactive) { _%>
+        return userService.registerUser(managedUserVM, managedUserVM.getPassword())
+            .doOnSuccess(mailService::sendActivationEmail)
+            .then();
+  <%_ } else { _%>
+        <%= user.persistClass %> user = userService.registerUser(managedUserVM, managedUserVM.getPassword());
+        mailService.sendActivationEmail(user);
+  <%_ } _%>
+    }
+
+    /**
+     * {@code GET  /activate} : activate the registered user.
+     *
+     * @param key the activation key.
+     * @throws RuntimeException {@code 500 (Internal Server Error)} if the user couldn't be activated.
+     */
+    @GetMapping("/activate")
+    public <% if (reactive) { %>Mono<Void><% } else { %>void<% } %> activateAccount(@RequestParam(value = "key") String key) {
+  <%_ if (reactive) { _%>
+        return userService.activateRegistration(key)
+            .switchIfEmpty(Mono.error(new AccountResourceException("No user was found for this activation key")))
+            .then();
+  <%_ } else { _%>
+        Optional<<%= user.persistClass %>> user = userService.activateRegistration(key);
+        if (!user.isPresent()) {
+            throw new AccountResourceException("No user was found for this activation key");
+        }
+  <%_ } _%>
+    }
+
+  <%_ if (!authenticationTypeJwt) { _%>
+    /**
+     * {@code GET  /authenticate} : check if the user is authenticated, and return its login.
+     *
+     * @param request the HTTP request.
+     * @return the login if the user is authenticated.
+     */
+    @GetMapping("/authenticate")
+    <%_ if (reactive) { _%>
+    public Mono<String> isAuthenticated(ServerWebExchange request) {
+        log.debug("REST request to check if the current user is authenticated");
+        return request.getPrincipal().map(Principal::getName);
+    <%_ } else { _%>
+    public String isAuthenticated(HttpServletRequest request) {
+        log.debug("REST request to check if the current user is authenticated");
+        return request.getRemoteUser();
+    <%_ } _%>
+    }
+
+  <%_ } _%>
+    /**
+     * {@code GET  /account} : get the current user.
+     *
+     * @return the current user.
+     * @throws RuntimeException {@code 500 (Internal Server Error)} if the user couldn't be returned.
+     */
+    @GetMapping("/account")
+    public <% if (reactive) { %>Mono<<%= user.adminUserDto %>><% } else { %><%= user.adminUserDto %><% } %> getAccount() {
+        return userService.getUserWithAuthorities()
+            .map(<%= user.adminUserDto %>::new)
+  <%_ if (reactive) { _%>
+            .switchIfEmpty(Mono.error(new AccountResourceException("User could not be found")));
+  <%_ } else { _%>
+            .orElseThrow(() -> new AccountResourceException("User could not be found"));
+  <%_ } _%>
+    }
+
+    /**
+     * {@code POST  /account} : update the current user information.
+     *
+     * @param userDTO the current user information.
+     * @throws EmailAlreadyUsedException {@code 400 (Bad Request)} if the email is already used.
+     * @throws RuntimeException {@code 500 (Internal Server Error)} if the user login wasn't found.
+     */
+    @PostMapping("/account")
+  <%_ if (reactive) { _%>
+    public Mono<Void> saveAccount(@Valid @RequestBody <%= user.adminUserDto %> userDTO) {
+        return SecurityUtils.getCurrentUserLogin()
+            .switchIfEmpty(Mono.error(new AccountResourceException("Current user login not found")))
+            .flatMap(userLogin -> userRepository.findOneByEmailIgnoreCase(userDTO.getEmail())
+                .filter(existingUser -> !existingUser.getLogin().equalsIgnoreCase(userLogin))
+                .hasElement()
+                .flatMap(emailExists -> {
+                    if (emailExists) {
+                        throw new EmailAlreadyUsedException();
+                    }
+                    return userRepository.findOneByLogin(userLogin);
+                }))
+                .switchIfEmpty(Mono.error(new AccountResourceException("User could not be found")))
+                .flatMap(user -> userService.updateUser(userDTO.getFirstName(), userDTO.getLastName(), userDTO.getEmail(),
+                    userDTO.getLangKey()<% if (databaseTypeSql || databaseTypeMongodb || databaseTypeCouchbase || databaseTypeNeo4j) { %>, userDTO.getImageUrl()<% } %>));
+  <%_ } else { _%>
+    public void saveAccount(@Valid @RequestBody <%= user.adminUserDto %> userDTO) {
+        String userLogin = SecurityUtils.getCurrentUserLogin().orElseThrow(() -> new AccountResourceException("Current user login not found"));
+        Optional<<%= user.persistClass %>> existingUser = userRepository.findOneByEmailIgnoreCase(userDTO.getEmail());
+        if (existingUser.isPresent() && (!existingUser.orElseThrow().getLogin().equalsIgnoreCase(userLogin))) {
+            throw new EmailAlreadyUsedException();
+        }
+        Optional<<%= user.persistClass %>> user = userRepository.findOneByLogin(userLogin);
+        if (!user.isPresent()) {
+            throw new AccountResourceException("User could not be found");
+        }
+        userService.updateUser(userDTO.getFirstName(), userDTO.getLastName(), userDTO.getEmail(),
+            userDTO.getLangKey()<% if (databaseTypeSql || databaseTypeMongodb || databaseTypeCouchbase || databaseTypeNeo4j) { %>, userDTO.getImageUrl()<% } %>);
+  <%_ } _%>
+    }
+
+    /**
+     * {@code POST  /account/change-password} : changes the current user's password.
+     *
+     * @param passwordChangeDto current and new password.
+     * @throws InvalidPasswordException {@code 400 (Bad Request)} if the new password is incorrect.
+     */
+    @PostMapping(path = "/account/change-password")
+    public <% if (reactive) { %>Mono<Void><% } else { %>void<% } %> changePassword(@RequestBody PasswordChangeDTO passwordChangeDto) {
+        if (isPasswordLengthInvalid(passwordChangeDto.getNewPassword())) {
+            throw new InvalidPasswordException();
+        }
+        <% if (reactive) { %>return <% } %>userService.changePassword(passwordChangeDto.getCurrentPassword(), passwordChangeDto.getNewPassword());
+    }
+  <%_ if (authenticationTypeSession && !reactive) { _%>
+
+    /**
+     * {@code GET  /account/sessions} : get the current open sessions.
+     *
+     * @return the current open sessions.
+     * @throws RuntimeException {@code 500 (Internal Server Error)} if the current open sessions couldn't be retrieved.
+     */
+    @GetMapping("/account/sessions")
+    public List<PersistentToken> getCurrentSessions() {
+        return persistentTokenRepository.findByUser(
+            userRepository.findOneByLogin(SecurityUtils.getCurrentUserLogin()
+                .orElseThrow(() -> new AccountResourceException("Current user login not found")))
+                    .orElseThrow(() -> new AccountResourceException("User could not be found"))
+        );
+    }
+
+    /**
+     * {@code DELETE  /account/sessions?series={series}} : invalidate an existing session.
+     *
+     * - 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.
+     *
+     * @param series the series of an existing session.
+     * @throws IllegalArgumentException if the series couldn't be URL decoded.
+     */
+    @DeleteMapping("/account/sessions/{series}")
+    public void invalidateSession(@PathVariable String series) {
+        String decodedSeries = URLDecoder.decode(series, StandardCharsets.UTF_8);
+        SecurityUtils.getCurrentUserLogin()
+            .flatMap(userRepository::findOneByLogin)
+            .ifPresent(u ->
+                persistentTokenRepository.findByUser(u).stream()
+                    .filter(persistentToken -> StringUtils.equals(persistentToken.getSeries(), decodedSeries))
+    <%_ if (databaseTypeSql || databaseTypeMongodb) { _%>
+                    .findAny().ifPresent(t -> persistentTokenRepository.deleteById(decodedSeries)));
+    <%_ } else if (databaseTypeCouchbase) { _%>
+                    .findAny().ifPresent(t -> persistentTokenRepository.deleteBySeries(decodedSeries)));
+    <%_ } else { _%>
+                    .findAny().ifPresent(persistentTokenRepository::delete));
+    <%_ } _%>
+    }
+  <%_ } _%>
+
+    /**
+     * {@code POST   /account/reset-password/init} : Send an email to reset the password of the user.
+     *
+     * @param mail the mail of the user.
+     */
+    @PostMapping(path = "/account/reset-password/init")
+  <%_ if (reactive) { _%>
+    public Mono<Void> requestPasswordReset(@RequestBody String mail) {
+        return userService.requestPasswordReset(mail)
+            .doOnSuccess(user -> {
+                if (Objects.nonNull(user)) {
+                    mailService.sendPasswordResetMail(user);
+                } else {
+                    // Pretend the request has been successful to prevent checking which emails really exist
+                    // but log that an invalid attempt has been made
+                    log.warn("Password reset requested for non existing mail");
+                }
+            })
+            .then();
+  <%_ } else { _%>
+    public void requestPasswordReset(@RequestBody String mail) {
+        Optional<<%= user.persistClass %>> user = userService.requestPasswordReset(mail);
+        if (user.isPresent()) {
+            mailService.sendPasswordResetMail(user.orElseThrow());
+        } else {
+            // Pretend the request has been successful to prevent checking which emails really exist
+            // but log that an invalid attempt has been made
+            log.warn("Password reset requested for non existing mail");
+        }
+  <%_ } _%>
+    }
+
+    /**
+     * {@code POST   /account/reset-password/finish} : Finish to reset the password of the user.
+     *
+     * @param keyAndPassword the generated key and the new password.
+     * @throws InvalidPasswordException {@code 400 (Bad Request)} if the password is incorrect.
+     * @throws RuntimeException {@code 500 (Internal Server Error)} if the password could not be reset.
+     */
+    @PostMapping(path = "/account/reset-password/finish")
+    public <% if (reactive) { %>Mono<Void><% } else { %>void<% } %> finishPasswordReset(@RequestBody KeyAndPasswordVM keyAndPassword) {
+        if (isPasswordLengthInvalid(keyAndPassword.getNewPassword())) {
+            throw new InvalidPasswordException();
+        }
+  <%_ if (reactive) { _%>
+        return userService.completePasswordReset(keyAndPassword.getNewPassword(), keyAndPassword.getKey())
+            .switchIfEmpty(Mono.error(new AccountResourceException("No user was found for this reset key")))
+            .then();
+  <%_ } else { _%>
+        Optional<<%= user.persistClass %>> user =
+            userService.completePasswordReset(keyAndPassword.getNewPassword(), keyAndPassword.getKey());
+
+        if (!user.isPresent()) {
+            throw new AccountResourceException("No user was found for this reset key");
+        }
+  <%_ } _%>
+    }
+
+    private static boolean isPasswordLengthInvalid(String password) {
+        return StringUtils.isEmpty(password) ||
+            password.length() < ManagedUserVM.PASSWORD_MIN_LENGTH ||
+            password.length() > ManagedUserVM.PASSWORD_MAX_LENGTH;
+    }
+}

package/dist/generators/server/templates/src/main/java/_package_/web/rest/AccountResource_oauth2.java.ejs

@@ -0,0 +1,100 @@
+<%#
+ Copyright 2013-2023 the original author or authors from the JHipster project.
+
+ This file is part of the JHipster project, see https://www.jhipster.tech/
+ for more information.
+
+ 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
+
+      https://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 <%= packageName %>.web.rest;
+
+<%_ if (reactive) { _%>
+import <%= packageName %>.security.SecurityUtils;
+<%_ } _%>
+import <%= packageName %>.service.UserService;
+import <%= packageName %>.service.dto.<%= user.adminUserDto %>;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.security.authentication.AbstractAuthenticationToken;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+<%_ if (reactive) { _%>
+import org.springframework.web.server.ServerWebExchange;
+import reactor.core.publisher.Mono;
+<%_ } else { _%>
+import jakarta.servlet.http.HttpServletRequest;
+<%_ } _%>
+
+import java.security.Principal;
+
+/**
+ * REST controller for managing the current user's account.
+ */
+@RestController
+@RequestMapping("/api")
+public class AccountResource {
+
+    private static class AccountResourceException extends RuntimeException {
+
+        private static final long serialVersionUID = 1L;
+
+        private AccountResourceException(String message) {
+            super(message);
+        }
+    }
+
+    private final Logger log = LoggerFactory.getLogger(AccountResource.class);
+
+    private final UserService userService;
+
+    public AccountResource(UserService userService) {
+        this.userService = userService;
+    }
+
+    /**
+     * {@code GET  /account} : get the current user.
+     *
+     * @param principal the current user; resolves to {@code null} if not authenticated.
+     * @return the current user.
+     * @throws AccountResourceException {@code 500 (Internal Server Error)} if the user couldn't be returned.
+     */
+    @GetMapping("/account")
+    @SuppressWarnings("unchecked")
+    public <% if (reactive) { %>Mono<<%= user.adminUserDto %>><% } else { %><%= user.adminUserDto %><% } %> getAccount(Principal principal) {
+        if (principal instanceof AbstractAuthenticationToken) {
+            return userService.getUserFromAuthentication((AbstractAuthenticationToken) principal);
+        } else {
+            throw new AccountResourceException("User could not be found");
+        }
+    }
+
+    /**
+     * {@code GET  /authenticate} : check if the user is authenticated, and return its login.
+     *
+     * @param request the HTTP request.
+     * @return the login if the user is authenticated.
+     */
+    @GetMapping("/authenticate")
+<%_ if (reactive) { _%>
+    public Mono<String> isAuthenticated(ServerWebExchange request) {
+        log.debug("REST request to check if the current user is authenticated");
+        return request.getPrincipal().map(Principal::getName);
+<%_ } else { _%>
+    public String isAuthenticated(HttpServletRequest request) {
+        log.debug("REST request to check if the current user is authenticated");
+        return request.getRemoteUser();
+<%_ } _%>
+    }
+}

package/dist/generators/server/templates/src/main/java/_package_/web/rest/AccountResource_skipUserManagement.java.ejs

@@ -0,0 +1,198 @@
+<%#
+ Copyright 2013-2023 the original author or authors from the JHipster project.
+
+ This file is part of the JHipster project, see https://www.jhipster.tech/
+ for more information.
+
+ 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
+
+      https://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 <%= packageName %>.web.rest;
+
+<%_ if (reactive) { _%>
+import reactor.core.publisher.Mono;
+<%_ } else { _%>
+import jakarta.servlet.http.HttpServletRequest;
+<%_ } _%>
+
+<%_ if (authenticationTypeOauth2) { _%>
+import org.springframework.security.oauth2.client.authentication.OAuth2AuthenticationToken;
+  <%_ if (reactive) { _%>
+import org.springframework.web.server.ServerWebExchange;
+  <%_ } _%>
+<%_ } _%>
+<%_ if (authenticationTypeOauth2 || authenticationTypeJwt) { _%>
+import java.security.Principal;
+import org.springframework.security.oauth2.server.resource.authentication.JwtAuthenticationToken;
+import org.springframework.security.authentication.AbstractAuthenticationToken;
+<%_ } else { _%>
+  <%_ if (reactive) { _%>
+import java.security.Principal;
+import org.springframework.web.server.ServerWebExchange;
+import org.springframework.security.core.context.ReactiveSecurityContextHolder;
+import org.springframework.security.core.context.SecurityContext;
+import org.springframework.security.core.userdetails.UserDetails;
+  <%_ } else { _%>
+import <%= packageName %>.security.SecurityUtils;
+import org.springframework.security.core.context.SecurityContextHolder;
+  <%_ } _%>
+<%_ } _%>
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.security.core.GrantedAuthority;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.Set;
+import java.util.stream.Collectors;
+
+@RestController
+@RequestMapping("/api")
+public class AccountResource {
+
+    private final Logger log = LoggerFactory.getLogger(AccountResource.class);
+
+    private static class AccountResourceException extends RuntimeException {
+<%_ if (authenticationTypeOauth2 || authenticationTypeJwt) { _%>
+        private static final long serialVersionUID = 1L;
+
+        private AccountResourceException(String message) {
+            super(message);
+        }
+<%_ } _%>
+    }
+
+    /**
+     * {@code GET  /account} : get the current user.
+     *
+<%_ if (authenticationTypeOauth2 || authenticationTypeJwt) { _%>
+     * @param principal the current user; resolves to {@code null} if not authenticated.
+<%_ } _%>
+     * @return the current user.
+     * @throws AccountResourceException {@code 500 (Internal Server Error)} if the user couldn't be returned.
+     */
+    @GetMapping("/account")
+<%_ if (reactive) { _%>
+  <%_ if (authenticationTypeOauth2 || authenticationTypeJwt) { _%>
+    public Mono<UserVM> getAccount(Principal principal) {
+        if (principal instanceof AbstractAuthenticationToken) {
+            return Mono.just(getUserFromAuthentication((AbstractAuthenticationToken) principal));
+        } else {
+            throw new AccountResourceException("User could not be found");
+        }
+    }
+  <%_ } else { _%>
+    public Mono<UserVM> getAccount() {
+        return ReactiveSecurityContextHolder.getContext()
+            .map(SecurityContext::getAuthentication)
+            .map(authentication -> {
+                String login;
+                if (authentication.getPrincipal() instanceof UserDetails) {
+                    login = ((UserDetails) authentication.getPrincipal()).getUsername();
+                } else if (authentication.getPrincipal() instanceof String) {
+                    login = (String) authentication.getPrincipal();
+                } else {
+                    throw new AccountResourceException();
+                }
+                Set<String> authorities = authentication.getAuthorities().stream()
+                    .map(GrantedAuthority::getAuthority)
+                    .collect(Collectors.toSet());
+                return new UserVM(login, authorities);
+            })
+            .switchIfEmpty(Mono.error(new AccountResourceException()));
+    }
+  <%_ } _%>
+<%_ } else { _%>
+  <%_ if (authenticationTypeOauth2 || authenticationTypeJwt) { _%>
+    public UserVM getAccount(Principal principal) {
+        if (principal instanceof AbstractAuthenticationToken) {
+            return getUserFromAuthentication((AbstractAuthenticationToken) principal);
+        } else {
+            throw new AccountResourceException("User could not be found");
+        }
+    }
+  <%_ } else { _%>
+    public UserVM getAccount() {
+        String login = SecurityUtils.getCurrentUserLogin()
+            .orElseThrow(AccountResourceException::new);
+        Set<String> authorities = SecurityContextHolder.getContext().getAuthentication().getAuthorities().stream()
+            .map(GrantedAuthority::getAuthority)
+            .collect(Collectors.toSet());
+        return new UserVM(login, authorities);
+    }
+  <%_ } _%>
+<%_ } _%>
+<%_ if (!authenticationTypeJwt) { _%>
+
+    /**
+     * {@code GET  /authenticate} : check if the user is authenticated, and return its login.
+     *
+     * @param request the HTTP request.
+     * @return the login if the user is authenticated.
+     */
+    @GetMapping("/authenticate")
+  <%_ if (reactive) { _%>
+    public Mono<String> isAuthenticated(ServerWebExchange request) {
+        log.debug("REST request to check if the current user is authenticated");
+        return request.getPrincipal().map(Principal::getName);
+  <%_ } else { _%>
+    public String isAuthenticated(HttpServletRequest request) {
+        log.debug("REST request to check if the current user is authenticated");
+        return request.getRemoteUser();
+  <%_ } _%>
+    }
+<%_ } _%>
+
+    private static class UserVM {
+        private String login;
+        private Set<String> authorities;
+
+        @JsonCreator
+        UserVM(String login, Set<String> authorities) {
+            this.login = login;
+            this.authorities = authorities;
+        }
+
+        public boolean isActivated() {
+            return true;
+        }
+
+        public Set<String> getAuthorities() {
+            return authorities;
+        }
+
+        public String getLogin() {
+            return login;
+        }
+    }
+<%_ if (authenticationTypeOauth2 || authenticationTypeJwt) { _%>
+
+    private UserVM getUserFromAuthentication(AbstractAuthenticationToken authToken) {
+        if (
+  <%_ if (authenticationTypeOauth2) { _%>
+            !(authToken instanceof OAuth2AuthenticationToken) &&
+  <%_ } _%>
+            !(authToken instanceof JwtAuthenticationToken)
+        ) {
+            throw new IllegalArgumentException("AuthenticationToken is not OAuth2 or JWT!");
+        }
+
+        return new UserVM(
+            authToken.getName(),
+            authToken.getAuthorities().stream().map(GrantedAuthority::getAuthority).collect(Collectors.toSet())
+        );
+    }
+<%_ } _%>
+}