@Entity
@Table(name="users")
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;

    @NotBlank
    @Email
    private String login;

    @NotBlank
    private String password;

    @NotBlank
    @Column(name = "name")
    private String username;

    @JsonIgnore
    @OneToOne(cascade = CascadeType.ALL)
    @JoinColumn(name = "id_role", referencedColumnName = "id")
    private Role roles;

    public User() {
    }
    
    public User(int id, String name, String login, String password, Role role) {
        this.id = id;
        this.username = name;
        this.login = login;
        this.password = password;
        this.roles = role;
    }


    public int getId() {
        return id;
    }

    public String getUsername() {
        return username;
    }

    public String getLogin() {
        return login;
    }

    public String getPassword() {
        return password;
    }

    public Role getRoles() {
        return roles;
    }

}

@Entity
@Table(name="roles")
public class Role
        implements GrantedAuthority {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;

    @NotBlank
    private String role;

    @OneToMany(mappedBy = "roles")
    private Collection<User> users;

    public int getId() {
        return id;
    }

    public Collection<User> getUsers() {
        return users;
    }

    @Override
    public String getAuthority() {
        return role;
    }
}

public class CustomUserDetails
        implements UserDetails {

    private final int id;

    private final String name;

    private final String username;

    private final String email;

    private final String password;

    private final Collection<? extends GrantedAuthority> authorities;

    private CustomUserDetails(int id, String name, String login, String password,
                              Collection<? extends GrantedAuthority> authorities) {
        this.id = id;
        this.name = name;
        this.username = null;
        this.email = login;
        this.password = password;
        this.authorities = authorities;
    }

    public static CustomUserDetails create(User user) {
        List<GrantedAuthority> authorities = Collections.singletonList(
                new SimpleGrantedAuthority((user.getRoles()).getAuthority()));

        return new CustomUserDetails(
                user.getId(),
                user.getUsername(),
                user.getLogin(),
                user.getPassword(),
                authorities
        );
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public String getEmail() {
        return email;
    }

    @Override
    public String getUsername() {
        return username;
    }

    @Override
    public String getPassword() {
        return password;
    }

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return authorities;
    }

    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    @Override
    public boolean isEnabled() {
        return true;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        CustomUserDetails that = (CustomUserDetails) o;
        return Objects.equals(id, that.id);
    }

    @Override
    public int hashCode() {

        return Objects.hash(id);
    }
}

@Service
public class CustomUserDetailsService
        implements UserDetailsService {

    final UserRepository userRepository;

    private static final Logger logger = LoggerFactory.getLogger(CustomUserDetailsService.class);

    public CustomUserDetailsService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    @Override
    @Transactional
    public UserDetails loadUserByUsername(String login)
            throws UsernameNotFoundException {

        User user = userRepository.findByLogin(login);

        if(user == null) {
            logger.error("User not found with email {}", login);
            throw new UsernameNotFoundException("User not found with login: " + login);
        }

        return CustomUserDetails.create(user);
    }

    @Transactional
    public UserDetails loadUserById(int id) {
        User user = userRepository.findById(id);

        if(user == null) {
            logger.error("User not found with id {}", id);
            throw new UsernameNotFoundException("User not found with id: " + id);
        }

        return CustomUserDetails.create(user);
    }
}

@RestController
@RequestMapping("/api")
public class UserController {

    final UserRepository mUserRepository;

    final CustomUserDetailsService mCustomUserDetailsService;

    public UserController(UserRepository mUserRepository, CustomUserDetailsService customUserDetailsService) {
        this.mUserRepository = mUserRepository;
        this.mCustomUserDetailsService = customUserDetailsService;
    }

    @GetMapping("/user/{id}")
    public BaseResponse<?> getUserName(@PathVariable int id) {
        User user = mUserRepository.findById(id);

        if(user != null) {

            Authentication auth = SecurityContextHolder.getContext().getAuthentication();

            for(GrantedAuthority role : auth.getAuthorities()) {
                System.out.println(role.getAuthority()); // ЗДЕСЬ ВСЕ ОК, ВЫЛАЗИТ ТА РОЛЬ, ЧТО В БД
            }

            return new BaseResponse<>(HttpStatus.OK, null, user);
        }

        return new BaseResponse<>(HttpStatus.NOT_FOUND, null, "User not found");
    }

}

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(
        securedEnabled = true,
        jsr250Enabled = true,
        prePostEnabled = true
)
public class SecurityConfig
        extends WebSecurityConfigurerAdapter {

    private final JwtAuthenticationEntryPoint authenticationEntryPoint;
    final CustomUserDetailsService customUserDetailsService;

    @Bean
    public JwtAuthenticationFilter jwtAuthenticationFilter() {
        return new JwtAuthenticationFilter();
    }

    @Bean(BeanIds.AUTHENTICATION_MANAGER)
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }

    public SecurityConfig(JwtAuthenticationEntryPoint authenticationEntryPoint,
                          CustomUserDetailsService customUserDetailsService) {
        this.authenticationEntryPoint = authenticationEntryPoint;
        this.customUserDetailsService = customUserDetailsService;
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    @Override
    public void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth
                .userDetailsService(customUserDetailsService)
                .passwordEncoder(passwordEncoder());
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                .cors()
                .and()
                .csrf().disable()
                .exceptionHandling()
                .authenticationEntryPoint(authenticationEntryPoint)
                .and()
                .sessionManagement()
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                .authorizeRequests().antMatchers("/auth/**").permitAll()
                .and()
                .authorizeRequests().antMatchers("/api/**").hasRole("Admin")
                .anyRequest().authenticated()
                .and()
                .addFilterBefore(jwtAuthenticationFilter(), UsernamePasswordAuthenticationFilter.class);

    }
}