private UserDto getUser(DbSession dbSession, String login) { UserDto user = dbClient.userDao().selectByLogin(dbSession, login); if (user == null || !user.isActive()) { throw new NotFoundException(format("User '%s' doesn't exist", login)); } return user; }
private UserDto getUser(DbSession dbSession, String login) { UserDto user = dbClient.userDao().selectByLogin(dbSession, login); if (user == null || !user.isActive()) { throw new NotFoundException(format("User with login '%s' has not been found", login)); } return user; }
private UserDto getUser(DbSession dbSession, String login) { UserDto user = dbClient.userDao().selectByLogin(dbSession, login); if (user == null || !user.isActive()) { throw new NotFoundException(format("User '%s' doesn't exist", login)); } return user; }
private Optional<UserDto> selectUserFromUuid(String userUuid) { try (DbSession dbSession = dbClient.openSession(false)) { UserDto user = dbClient.userDao().selectByUuid(dbSession, userUuid); return Optional.ofNullable(user != null && user.isActive() ? user : null); } }
public UserDto reactivateAndCommit(DbSession dbSession, UserDto disabledUser, NewUser newUser, Consumer<UserDto> beforeCommit, UserDto... otherUsersToIndex) { checkArgument(!disabledUser.isActive(), "An active user with login '%s' already exists", disabledUser.getLogin()); reactivateUser(dbSession, disabledUser, newUser); return commitUser(dbSession, disabledUser, beforeCommit, otherUsersToIndex); }
private Users.User.Builder formatUser(UserDto user) { Users.User.Builder builder = Users.User.newBuilder() .setLogin(user.getLogin()) .setName(nullToEmpty(user.getName())) .setActive(user.isActive()); ofNullable(emptyToNull(user.getEmail())).ifPresent(email -> builder.setAvatar(avatarFactory.create(user))); return builder; }
private String getUserFullName(@Nullable String login) { if (login == null) { return null; } try (DbSession dbSession = dbClient.openSession(false)) { UserDto userDto = dbClient.userDao().selectByLogin(dbSession, login); if (userDto == null || !userDto.isActive()) { // most probably user was deleted return login; } return StringUtils.defaultIfBlank(userDto.getName(), login); } }
private void verifyThatUserIsDeactivated(String login) { Optional<UserDto> user = db.users().selectUserByLogin(login); assertThat(user).isPresent(); assertThat(user.get().isActive()).isFalse(); assertThat(user.get().getEmail()).isNull(); assertThat(user.get().getScmAccountsAsList()).isEmpty(); } }
private void verifyUserInDb(String expectedLogin, String expectedName, @Nullable String expectedEmail, GroupDto... expectedGroups) { UserDto userDto = db.users().selectUserByLogin(expectedLogin).get(); assertThat(userDto.isActive()).isTrue(); assertThat(userDto.getName()).isEqualTo(expectedName); assertThat(userDto.getEmail()).isEqualTo(expectedEmail); assertThat(userDto.getExternalLogin()).isEqualTo(expectedLogin); assertThat(userDto.getExternalIdentityProvider()).isEqualTo("sonarqube"); verityUserGroups(expectedLogin, expectedGroups); }
private static CreateWsResponse buildResponse(UserDto userDto) { CreateWsResponse.User.Builder userBuilder = CreateWsResponse.User.newBuilder() .setLogin(userDto.getLogin()) .setName(userDto.getName()) .setActive(userDto.isActive()) .setLocal(userDto.isLocal()) .addAllScmAccounts(userDto.getScmAccountsAsList()); ofNullable(emptyToNull(userDto.getEmail())).ifPresent(userBuilder::setEmail); return CreateWsResponse.newBuilder().setUser(userBuilder).build(); }
@Override public UserDto register(UserRegistration registration) { try (DbSession dbSession = dbClient.openSession(false)) { UserDto userDto = getUser(dbSession, registration.getUserIdentity(), registration.getProvider()); if (userDto == null) { return registerNewUser(dbSession, null, registration); } if (!userDto.isActive()) { return registerNewUser(dbSession, userDto, registration); } return registerExistingUser(dbSession, userDto, registration); } }
@Test public void indexOnStartup_adds_all_users_to_index() { UserDto user = db.users().insertUser(u -> u.setScmAccounts(asList("user_1", "u1"))); underTest.indexOnStartup(new HashSet<>()); List<UserDoc> docs = es.getDocuments(UserIndexDefinition.INDEX_TYPE_USER, UserDoc.class); assertThat(docs).hasSize(1); UserDoc doc = docs.get(0); assertThat(doc.uuid()).isEqualTo(user.getUuid()); assertThat(doc.login()).isEqualTo(user.getLogin()); assertThat(doc.name()).isEqualTo(user.getName()); assertThat(doc.email()).isEqualTo(user.getEmail()); assertThat(doc.active()).isEqualTo(user.isActive()); assertThat(doc.scmAccounts()).isEqualTo(user.getScmAccountsAsList()); assertThat(doc.organizationUuids()).isEmpty(); }
@Override public void handle(Request request, Response response) throws Exception { userSession.checkIsRoot(); String login = request.mandatoryParam(PARAM_LOGIN); try (DbSession dbSession = dbClient.openSession(false)) { UserDto userDto = dbClient.userDao().selectByLogin(dbSession, login); if (userDto == null || !userDto.isActive()) { throw new NotFoundException(format("User with login '%s' not found", login)); } if (!userDto.isRoot()) { dbClient.userDao().setRoot(dbSession, login, true); dbSession.commit(); } } response.noContent(); }
@Test public void create_user_with_minimum_fields() { createDefaultGroup(); underTest.createAndCommit(db.getSession(), NewUser.builder() .setLogin("us") .setName("User") .build(), u -> { }); UserDto dto = dbClient.userDao().selectByLogin(session, "us"); assertThat(dto.getId()).isNotNull(); assertThat(dto.getLogin()).isEqualTo("us"); assertThat(dto.getName()).isEqualTo("User"); assertThat(dto.getEmail()).isNull(); assertThat(dto.getScmAccounts()).isNull(); assertThat(dto.isActive()).isTrue(); }
@Override public void handle(Request request, Response response) throws Exception { userSession.checkIsRoot(); String login = request.mandatoryParam(PARAM_LOGIN); try (DbSession dbSession = dbClient.openSession(false)) { UserDto userDto = dbClient.userDao().selectByLogin(dbSession, login); if (userDto == null || !userDto.isActive()) { throw new NotFoundException(format("User with login '%s' not found", login)); } checkRequest(dbClient.userDao().countRootUsersButLogin(dbSession, login) > 0, "Last root can't be unset"); if (userDto.isRoot()) { dbClient.userDao().setRoot(dbSession, login, false); dbSession.commit(); } } response.noContent(); }
@Test public void reactivate_user() { logInAsSystemAdministrator(); db.users().insertUser(newUserDto("john", "John", "john@email.com").setActive(false)); userIndexer.indexOnStartup(new HashSet<>()); call(CreateRequest.builder() .setLogin("john") .setName("John") .setEmail("john@email.com") .setScmAccounts(singletonList("jn")) .setPassword("1234") .build()); assertThat(db.users().selectUserByLogin("john").get().isActive()).isTrue(); }
@Test public void setRoot_has_no_effect_on_root_flag_of_inactive_user() { String nonRootInactiveUser = insertUser(false).getLogin(); commit(() -> underTest.setRoot(session, nonRootInactiveUser, true)); assertThat(underTest.selectByLogin(session, nonRootInactiveUser).isRoot()).isFalse(); // create inactive root user UserDto rootUser = insertActiveUser(); commit(() -> underTest.setRoot(session, rootUser.getLogin(), true)); rootUser.setActive(false); commit(() -> underTest.update(session, rootUser)); UserDto inactiveRootUser = underTest.selectByLogin(session, rootUser.getLogin()); assertThat(inactiveRootUser.isRoot()).isTrue(); assertThat(inactiveRootUser.isActive()).isFalse(); commit(() -> underTest.setRoot(session, inactiveRootUser.getLogin(), false)); assertThat(underTest.selectByLogin(session, inactiveRootUser.getLogin()).isRoot()).isTrue(); }
private static IndexRequest newIndexRequest(UserDto user, ListMultimap<String, String> organizationUuidsByUserUuid) { UserDoc doc = new UserDoc(Maps.newHashMapWithExpectedSize(8)); // all the keys must be present, even if value is null doc.setUuid(user.getUuid()); doc.setLogin(user.getLogin()); doc.setName(user.getName()); doc.setEmail(user.getEmail()); doc.setActive(user.isActive()); doc.setScmAccounts(UserDto.decodeScmAccounts(user.getScmAccounts())); doc.setOrganizationUuids(organizationUuidsByUserUuid.get(user.getUuid())); return new IndexRequest(INDEX_TYPE_USER.getIndex(), INDEX_TYPE_USER.getType()) .id(doc.getId()) .routing(doc.getRouting()) .source(doc.getFields()); } }
/** * Serializes a user to the passed JsonWriter. */ public void write(JsonWriter json, UserDto user, Collection<String> groups, @Nullable Collection<String> fields) { json.beginObject(); json.prop(FIELD_LOGIN, user.getLogin()); writeIfNeeded(json, user.getName(), FIELD_NAME, fields); if (userSession.isLoggedIn()) { writeIfNeeded(json, user.getEmail(), FIELD_EMAIL, fields); writeIfNeeded(json, user.isActive(), FIELD_ACTIVE, fields); writeIfNeeded(json, user.isLocal(), FIELD_LOCAL, fields); writeIfNeeded(json, user.getExternalLogin(), FIELD_EXTERNAL_IDENTITY, fields); writeIfNeeded(json, user.getExternalIdentityProvider(), FIELD_EXTERNAL_PROVIDER, fields); writeGroupsIfNeeded(json, groups, fields); writeScmAccountsIfNeeded(json, fields, user); } json.endObject(); }
@Test public void reactivate_user_without_providing_login() { UserDto user = db.users().insertUser(u -> u.setActive(false)); createDefaultGroup(); underTest.reactivateAndCommit(db.getSession(), user, NewUser.builder() .setName("Marius2") .setEmail("marius2@mail.com") .setPassword("password2") .build(), u -> { }); UserDto reloaded = dbClient.userDao().selectByUuid(session, user.getUuid()); assertThat(reloaded.isActive()).isTrue(); assertThat(reloaded.getLogin()).isEqualTo(user.getLogin()); }