Jave find by username user repository

@Test
public void testFindByUsername() {
    userRepository.save(user);
    User dbUser = userRepository.findByUsername(user.getUsername());

    assertNotNull(dbUser);
}
 

@Override
public Maybe<User> findByUsernameAndDomain(String domain, String username) {
    return Observable.fromPublisher(
            usersCollection
                    .find(and(eq(FIELD_REFERENCE_TYPE, DOMAIN.name()), eq(FIELD_REFERENCE_ID, domain), eq(FIELD_USERNAME, username)))
                    .limit(1)
                    .first())
            .firstElement()
            .map(this::convert);
}
 

@Override
public User findByUsername(String username) {
    final String sql = " select * from user_ where username = ? and archived = 0 ";
    final List<User> list = this.jdbcTemplate.query(sql, new Object[]{username}, userRowMapper);

    User user = null;
    if (!list.isEmpty()) {
        user = list.get(0);
        user.privileges().addAll(findPrivileges(user.id()));
    }

    return user;
}
 

@Test
void findUserByUsername() {
  // given
  String username = "user";

  // when
  UserCredentials userCredentials = userRepository.findByUsername(username);

  // then
  assertThat(userCredentials).isNotNull();
}
 

@Test
public void testFindByUsernameAndProviderIdAndProviderUserId(){
    setupUserSocialConnectionList();
    
    UserSocialConnection result = userSocialConnectionRepository.findByUserIdAndProviderIdAndProviderUserId("jiwhiz", "google", "google-jiwhiz");
    assertNotNull(result);

    result = userSocialConnectionRepository.findByUserIdAndProviderIdAndProviderUserId("jiwhiz", "google", "google-jiwhiz2");
    assertNull(result);
}
 

List<User> findByUsernameContainingIgnoreCase(String name,
Pageable pageable);
 

@EntityGraph(attributePaths = "permissions")
Optional<BasicUser> findDetailedByUsername(String username);
 

@Query("select t from User t where t.username = :username")
User findByUsername(@Param("username") String username);
 

@Test
public void shouldFindUserByUsername() {
    //Given
    final User user = UserBuilder.userBuilder().build();
    final User savedUser = userRepository.save(user);

    //When
    final Optional<User> userFound = userRepository.findByUsername(user.getUsername());

    //Then
    assertThat(userFound.isPresent()).isTrue();
    assertThat(userFound.get()).isEqualTo(savedUser);
}
 

@Query("select * from ba_user where username = :username")
Optional<User> findByUsername(@Bind("username") String username);
 

@Query("select password from ba_user where username = :username and enabled = true")
Optional<String> findPasswordByUsername(@Bind("username") String username);
 

public User findUserByUsernameOrEmail(String username) {
  return users.stream()
    .filter(user -> user.getUsername().equalsIgnoreCase(username) || user.getEmail().equalsIgnoreCase(username))
    .findFirst().get();
}
 

@Override
public User findByUsername(String username) {
    return mongoOperations.findOne(new Query(Criteria.where("username").is(username)), User.class);
}
 

@Override
public User findByUsername(String username) {
    return mongoOperations.findOne(new Query(Criteria.where("username").is(username)), User.class);
}
 

@Override
public Mono<UserDetails> findByUsername(String username) {
	return userRepository.findByUsername(username)
			.switchIfEmpty(Mono.error(new UsernameNotFoundException(username)))
			.flatMap(user -> Mono.just(new CustomUserDetails(user)));
}
 

@Override
public Mono<UserDetails> findByUsername(String username) {
	// FIXME case insensitive support
	UserDetails result = users.get(username);
	return result == null ? Mono.empty() : Mono.just(result);
}
 

@Test
public void findByUsernameWhenNoUserShouldReturnNull() throws Exception {
	this.entityManager.persist(new User("donald", VIN));
	User user = this.repository.findByUsername("minnie");
	assertThat(user).isNull();
}
 

@Query("SELECT u FROM User u WHERE (u.deletedOn > CURRENT_TIMESTAMP OR u.deletedOn IS NULL) AND u.username = :username")
User findActiveByUsername(@Param("username") String username);
 

@Cacheable("byUsername")
User findByUsername(String username);
 

/**
 * 通过用户名查找用户.
 *
 * @param username 用户名
 * @return 结果
 */
Optional<SysUser> findFirstByUsername(String username);
 

/**
 * Returns the user details for the received username.
 * 
 * @param username
 *            username to search for
 * @return the user details for the received username
 */
public PersistentUserDetails findOneByUsername(final String username);
 

/**
 * 根据用户名查询用户
 * @param username 用户名
 * @return User
 */
User findByUsername(String username);
 

/**
 * @param username 用户名
 * @param password 密码
 * @return 返回用户 否则为空
 * */
User findByUsernameAndPassword(String username , String password);
 

/**
 * 根据用户名查询用户信息
 *
 * @param username 用户名
 * @return 查询结果
 */
List<User> findAllByUsername(String username);
 

/**
 * 根据用户名称查找用户
 *
 * @param username 用户名
 * @return 用户信息
 */
UserEntity findByUsername(String username);
 

/**
 * Retrieve <code>User</code> from the data store by username.
 *
 * @param lastName
 *            Value to search for
 * @return a <code>Collection</code> of matching <code>User</code>s (or an
 *         empty <code>Collection</code> if none found)
 */
User findByUsername(String username) throws DataAccessException;
 

/**
 * Find an {@link User} by the username
 * 
 * @param username the username to find the {@link User} object
 * @return an {@link Optional} of the {@link User}
 */
Optional<User> findByUsername(String username);
 

List<User> findByUsernameLikeIgnoreCase(String username); 

UserEntity findByUsernameAndPassword(String username,String password); 

User findByUsername(String username); 

User findOneByIdOrUsernameIgnoreCase(String id, String userName); 

UserDO findByUsername(final String usernmae); 

Optional<User> findOneByUsername(String username); 

UserCredentials findByUsername(String username); 

Page<UserAccountEntity> findByUsernameLike(String username, Pageable page); 

User findByUsernameAndPasswordAndEnable(String username, String password, boolean enable); 

ManagerUser findByUsername(String username); 

Optional<UserProfile> findOneByUsername(String username); 

Optional<AdminUser> findByUsername(final String userName); 

User findByUsername(String username); 

User findByUsername(String username); 

User findByUsername(String username); 

public abstract User findByUsernameAndOrgi(String paramString, String orgi); 

UserEntity findByUsername(String username); 

Mono<User> findByUsername(String username); 

UserInfo findByUsernameAndAuthType(String username, AuthType authType); 

Iterable<UserInfo> findByOrderByUsernameAsc(); 

List<UserPO> findByUsernameIn(List<String> userNames); 

Mono<User> findByUsername(final String username); 

Optional<User> findByUsername(@NotBlank String username); 

Optional<User> findByUsernameOrEmail(String username, String email); 

User findByUsername(String username); 

User findByUsername(String username); 

public abstract User findByUsernameAndDatastatus(String username, boolean datastatus); 

public abstract User findByUsernameAndPassword(String paramString1, String password); 

public abstract User findByUsernameAndPasswordAndDatastatus(String username, String password,boolean datastatus); 

User findByUsername(String username); 

public abstract Page<User> findByDatastatusAndOrgiAndUsernameLike(boolean datastatus , String orgi ,String username ,Pageable paramPageable); 

public User findByUsername(String username); 

User findByUsernameIgnoreCase(String username);