#19.: revert bad clean

jhipster/src/main/java/it/economics/kata/security/DomainUserDetailsService.java

@@ -0,0 +1,61 @@
+package it.economics.kata.security;
+
+import it.economics.kata.domain.User;
+import it.economics.kata.repository.UserRepository;
+import org.hibernate.validator.internal.constraintvalidators.hv.EmailValidator;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.security.core.GrantedAuthority;
+import org.springframework.security.core.authority.SimpleGrantedAuthority;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.security.core.userdetails.UserDetailsService;
+import org.springframework.security.core.userdetails.UsernameNotFoundException;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+import java.util.Locale;
+import java.util.stream.Collectors;
+
+/**
+ * Authenticate a user from the database.
+ * https://www.baeldung.com/spring-security-authentication-with-a-database
+ */
+@Component("userDetailsService")
+public class DomainUserDetailsService implements UserDetailsService {
+
+  private final Logger log = LoggerFactory.getLogger(DomainUserDetailsService.class);
+
+  private final UserRepository userRepository;
+
+  public DomainUserDetailsService(UserRepository userRepository) {
+    this.userRepository = userRepository;
+  }
+
+  @Override
+  @Transactional
+  public UserDetails loadUserByUsername(final String login) {
+    log.debug("Authenticating {}", login);
+
+    if (new EmailValidator().isValid(login, null)) {
+      return userRepository.findOneWithAuthoritiesByEmailIgnoreCase(login)
+        .map(user -> createSpringSecurityUser(login, user))
+        .orElseThrow(() -> new UsernameNotFoundException("User with email " + login + " was not found in the database"));
+    }
+
+    String lowercaseLogin = login.toLowerCase(Locale.ENGLISH);
+    return userRepository.findOneWithAuthoritiesByLogin(lowercaseLogin)
+      .map(user -> createSpringSecurityUser(lowercaseLogin, user))
+      .orElseThrow(() -> new UsernameNotFoundException("User " + lowercaseLogin + " was not found in the database"));
+
+  }
+
+  private org.springframework.security.core.userdetails.User createSpringSecurityUser(String lowercaseLogin, User user) {
+    List<GrantedAuthority> grantedAuthorities = user.getAuthorities().stream()
+      .map(authority -> new SimpleGrantedAuthority(authority.getName()))
+      .collect(Collectors.toList());
+    return new org.springframework.security.core.userdetails.User(user.getLogin(),
+      user.getPassword(),
+      grantedAuthorities);
+  }
+}

jhipster/src/test/java/it/economics/kata/security/DomainUserDetailsServiceIT.java

@@ -0,0 +1,103 @@
+package it.economics.kata.security;
+
+import it.economics.kata.SfoGateAssignmentProblemApp;
+import it.economics.kata.domain.User;
+import it.economics.kata.repository.UserRepository;
+import org.apache.commons.lang3.RandomStringUtils;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.security.core.userdetails.UserDetailsService;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.Locale;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Integrations tests for {@link DomainUserDetailsService}.
+ */
+@SpringBootTest(classes = SfoGateAssignmentProblemApp.class)
+@Transactional
+public class DomainUserDetailsServiceIT {
+
+  private static final String USER_ONE_LOGIN = "test-user-one";
+  private static final String USER_ONE_EMAIL = "test-user-one@localhost";
+  private static final String USER_TWO_LOGIN = "test-user-two";
+  private static final String USER_TWO_EMAIL = "test-user-two@localhost";
+  private static final String USER_THREE_LOGIN = "test-user-three";
+  private static final String USER_THREE_EMAIL = "test-user-three@localhost";
+
+  @Autowired
+  private UserRepository userRepository;
+
+  @Autowired
+  private UserDetailsService domainUserDetailsService;
+
+  @BeforeEach
+  public void init() {
+    User userOne = new User();
+    userOne.setLogin(USER_ONE_LOGIN);
+    userOne.setPassword(RandomStringUtils.random(60));
+    userOne.setEmail(USER_ONE_EMAIL);
+    userOne.setFirstName("userOne");
+    userOne.setLastName("doe");
+    userOne.setLangKey("en");
+    userRepository.save(userOne);
+
+    User userTwo = new User();
+    userTwo.setLogin(USER_TWO_LOGIN);
+    userTwo.setPassword(RandomStringUtils.random(60));
+    userTwo.setEmail(USER_TWO_EMAIL);
+    userTwo.setFirstName("userTwo");
+    userTwo.setLastName("doe");
+    userTwo.setLangKey("en");
+    userRepository.save(userTwo);
+
+    User userThree = new User();
+    userThree.setLogin(USER_THREE_LOGIN);
+    userThree.setPassword(RandomStringUtils.random(60));
+    userThree.setEmail(USER_THREE_EMAIL);
+    userThree.setFirstName("userThree");
+    userThree.setLastName("doe");
+    userThree.setLangKey("en");
+    userRepository.save(userThree);
+  }
+
+  @Test
+  public void assertThatUserCanBeFoundByLogin() {
+    UserDetails userDetails = domainUserDetailsService.loadUserByUsername(USER_ONE_LOGIN);
+    assertThat(userDetails).isNotNull();
+    assertThat(userDetails.getUsername()).isEqualTo(USER_ONE_LOGIN);
+  }
+
+  @Test
+  public void assertThatUserCanBeFoundByLoginIgnoreCase() {
+    UserDetails userDetails = domainUserDetailsService.loadUserByUsername(USER_ONE_LOGIN.toUpperCase(Locale.ENGLISH));
+    assertThat(userDetails).isNotNull();
+    assertThat(userDetails.getUsername()).isEqualTo(USER_ONE_LOGIN);
+  }
+
+  @Test
+  public void assertThatUserCanBeFoundByEmail() {
+    UserDetails userDetails = domainUserDetailsService.loadUserByUsername(USER_TWO_EMAIL);
+    assertThat(userDetails).isNotNull();
+    assertThat(userDetails.getUsername()).isEqualTo(USER_TWO_LOGIN);
+  }
+
+  @Test
+  public void assertThatUserCanBeFoundByEmailIgnoreCase() {
+    UserDetails userDetails = domainUserDetailsService.loadUserByUsername(USER_TWO_EMAIL.toUpperCase(Locale.ENGLISH));
+    assertThat(userDetails).isNotNull();
+    assertThat(userDetails.getUsername()).isEqualTo(USER_TWO_LOGIN);
+  }
+
+  @Test
+  public void assertThatEmailIsPrioritizedOverLogin() {
+    UserDetails userDetails = domainUserDetailsService.loadUserByUsername(USER_ONE_EMAIL);
+    assertThat(userDetails).isNotNull();
+    assertThat(userDetails.getUsername()).isEqualTo(USER_ONE_LOGIN);
+  }
+}