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); } }
private BulkChangeResult executeBulkChange(DbSession dbSession, Request request) { BulkChangeData bulkChangeData = new BulkChangeData(dbSession, request); BulkChangeResult result = new BulkChangeResult(bulkChangeData.issues.size()); IssueChangeContext issueChangeContext = IssueChangeContext.createUser(new Date(system2.now()), userSession.getUuid()); List<DefaultIssue> items = bulkChangeData.issues.stream() .filter(bulkChange(issueChangeContext, bulkChangeData, result)) .collect(MoreCollectors.toList()); issueStorage.save(dbSession, items); refreshLiveMeasures(dbSession, bulkChangeData, result); Set<String> assigneeUuids = items.stream().map(DefaultIssue::assignee).filter(Objects::nonNull).collect(toSet()); Map<String, UserDto> userDtoByUuid = dbClient.userDao().selectByUuids(dbSession, assigneeUuids).stream().collect(toMap(UserDto::getUuid, u -> u)); String authorUuid = requireNonNull(userSession.getUuid(), "User uuid cannot be null"); UserDto author = dbClient.userDao().selectByUuid(dbSession, authorUuid); checkState(author != null, "User with uuid '%s' does not exist"); items.forEach(sendNotification(bulkChangeData, userDtoByUuid, author)); return result; }
@CheckForNull private CeTask.User resolveSubmitter(DbSession dbSession, @Nullable String submitterUuid) { if (submitterUuid == null) { return null; } UserDto submitterDto = dbClient.userDao().selectByUuid(dbSession, submitterUuid); if (submitterDto != null) { return new CeTask.User(submitterUuid, submitterDto.getLogin()); } else { return new CeTask.User(submitterUuid, null); } }
private void writeUser(DbSession dbSession, Response response, String uuid) { try (JsonWriter json = response.newJsonWriter()) { json.beginObject(); json.name("user"); UserDto user = dbClient.userDao().selectByUuid(dbSession, uuid); checkState(user != null, "User with uuid '%s' doesn't exist", uuid); Set<String> groups = new HashSet<>(dbClient.groupMembershipDao().selectGroupsByLogins(dbSession, singletonList(uuid)).get(uuid)); userWriter.write(json, user, groups, UserJsonWriter.FIELDS); json.endObject().close(); } }
private IssueDto doSaveIssue(DbSession session, DefaultIssue issue, IssueChangeContext context, @Nullable String comment, Optional<RuleDefinitionDto> rule, ComponentDto project, ComponentDto component) { IssueDto issueDto = issueStorage.save(session, singletonList(issue)).iterator().next(); if (issue.type() != RuleType.SECURITY_HOTSPOT) { String assigneeUuid = issue.assignee(); UserDto assignee = assigneeUuid == null ? null : dbClient.userDao().selectByUuid(session, assigneeUuid); String authorUuid = context.userUuid(); UserDto author = authorUuid == null ? null : dbClient.userDao().selectByUuid(session, authorUuid); notificationService.scheduleForSending(new IssueChangeNotification() .setIssue(issue) .setAssignee(assignee) .setChangeAuthor(author) .setRuleName(rule.map(RuleDefinitionDto::getName).orElse(null)) .setProject(project) .setComponent(component) .setComment(comment)); } return issueDto; }
@Test public void selectByUuid() { UserDto user1 = db.users().insertUser(); UserDto user2 = db.users().insertUser(user -> user.setActive(false)); assertThat(underTest.selectByUuid(session, user1.getUuid())).isNotNull(); assertThat(underTest.selectByUuid(session, user2.getUuid())).isNotNull(); assertThat(underTest.selectByUuid(session, "unknown")).isNull(); }
private UserDto authenticateFromUserToken(String token) { Optional<String> authenticatedUserUuid = userTokenAuthentication.authenticate(token); if (!authenticatedUserUuid.isPresent()) { throw AuthenticationException.newBuilder() .setSource(Source.local(Method.BASIC_TOKEN)) .setMessage("Token doesn't exist") .build(); } try (DbSession dbSession = dbClient.openSession(false)) { UserDto userDto = dbClient.userDao().selectByUuid(dbSession, authenticatedUserUuid.get()); if (userDto == null || !userDto.isActive()) { throw AuthenticationException.newBuilder() .setSource(Source.local(Method.BASIC_TOKEN)) .setMessage("User doesn't exist") .build(); } return userDto; } }
@Test public void massSubmit_returns_tasks_for_each_CeTaskSubmit_populated_from_CeTaskSubmit_and_creates_CeQueue_row_for_each() { CeTaskSubmit taskSubmit1 = createTaskSubmit(CeTaskTypes.REPORT, newProjectDto("PROJECT_1"), "rob"); CeTaskSubmit taskSubmit2 = createTaskSubmit("some type"); List<CeTask> tasks = underTest.massSubmit(asList(taskSubmit1, taskSubmit2)); UserDto userDto1 = db.getDbClient().userDao().selectByUuid(db.getSession(), taskSubmit1.getSubmitterUuid()); assertThat(tasks).hasSize(2); verifyCeTask(taskSubmit1, tasks.get(0), null, userDto1); verifyCeTask(taskSubmit2, tasks.get(1), null, null); verifyCeQueueDtoForTaskSubmit(taskSubmit1); verifyCeQueueDtoForTaskSubmit(taskSubmit2); }
@Test public void createForUser_creates_guarded_organization_with_key_name_and_description_generated_from_user_login_and_name_and_associated_to_user() { UserDto user = db.users().insertUser(A_LOGIN); when(organizationValidation.generateKeyFrom(A_LOGIN)).thenReturn(SLUG_OF_A_LOGIN); enableCreatePersonalOrg(true); builtInQProfileRepositoryRule.initialize(); db.qualityGates().insertBuiltInQualityGate(); underTest.createForUser(dbSession, user); OrganizationDto organization = dbClient.organizationDao().selectByKey(dbSession, SLUG_OF_A_LOGIN).get(); assertThat(organization.getUuid()).isNotEmpty(); assertThat(organization.getKey()).isEqualTo(SLUG_OF_A_LOGIN); assertThat(organization.getName()).isEqualTo(user.getName()); assertThat(organization.getDescription()).isEqualTo(user.getName() + "'s personal organization"); assertThat(organization.getUrl()).isNull(); assertThat(organization.getAvatarUrl()).isNull(); assertThat(organization.isGuarded()).isTrue(); assertThat(organization.getSubscription()).isEqualTo(Subscription.FREE); assertThat(organization.getCreatedAt()).isEqualTo(A_DATE); assertThat(organization.getUpdatedAt()).isEqualTo(A_DATE); assertThat(db.getDbClient().userDao().selectByUuid(dbSession, user.getUuid()).getOrganizationUuid()).isEqualTo(organization.getUuid()); }
@Test public void massSubmit_returns_tasks_for_each_CeTaskSubmit_populated_from_CeTaskSubmit_and_creates_CeQueue_row_for_each() { String mainComponentUuid = randomAlphabetic(10); CeTaskSubmit taskSubmit1 = createTaskSubmit(CeTaskTypes.REPORT, newComponent(mainComponentUuid), "submitter uuid"); CeTaskSubmit taskSubmit2 = createTaskSubmit("some type"); UserDto userDto1 = db.getDbClient().userDao().selectByUuid(db.getSession(), taskSubmit1.getSubmitterUuid()); List<CeTask> tasks = underTest.massSubmit(asList(taskSubmit1, taskSubmit2)); assertThat(tasks).hasSize(2); verifyCeTask(taskSubmit1, tasks.get(0), null, userDto1); verifyCeTask(taskSubmit2, tasks.get(1), null, null); verifyCeQueueDtoForTaskSubmit(taskSubmit1); verifyCeQueueDtoForTaskSubmit(taskSubmit2); }
@Test public void update_only_login_of_external_account() { UserDto user = db.users().insertUser(newExternalUser(DEFAULT_LOGIN, "Marius", "marius@lesbronzes.fr")); createDefaultGroup(); underTest.updateAndCommit(session, user, new UpdateUser() .setLogin("new_login"), u -> { }); assertThat(dbClient.userDao().selectByLogin(session, DEFAULT_LOGIN)).isNull(); UserDto userReloaded = dbClient.userDao().selectByUuid(session, user.getUuid()); assertThat(userReloaded.getLogin()).isEqualTo("new_login"); // Following fields has not changed assertThat(userReloaded.isLocal()).isFalse(); assertThat(userReloaded.getExternalLogin()).isEqualTo(user.getExternalLogin()); assertThat(userReloaded.getExternalId()).isEqualTo(user.getExternalId()); assertThat(userReloaded.getName()).isEqualTo(user.getName()); assertThat(userReloaded.getEmail()).isEqualTo(user.getEmail()); assertThat(userReloaded.getScmAccountsAsList()).containsAll(user.getScmAccountsAsList()); assertThat(userReloaded.getSalt()).isEqualTo(user.getSalt()); assertThat(userReloaded.getCryptedPassword()).isEqualTo(user.getCryptedPassword()); }
@Test public void reactivate_user_with_external_provider() { UserDto user = db.users().insertDisabledUser(u -> u.setLocal(true)); createDefaultGroup(); underTest.reactivateAndCommit(db.getSession(), user, NewUser.builder() .setLogin(user.getLogin()) .setName(user.getName()) .setExternalIdentity(new ExternalIdentity("github", "john", "ABCD")) .build(), u -> { }); session.commit(); UserDto dto = dbClient.userDao().selectByUuid(session, user.getUuid()); assertThat(dto.isLocal()).isFalse(); assertThat(dto.getExternalId()).isEqualTo("ABCD"); assertThat(dto.getExternalLogin()).isEqualTo("john"); assertThat(dto.getExternalIdentityProvider()).isEqualTo("github"); }
@Test public void reactivate_user_with_local_provider() { UserDto user = db.users().insertDisabledUser(u -> u.setLocal(false) .setExternalId("ABCD") .setExternalLogin("john") .setExternalIdentityProvider("github")); createDefaultGroup(); underTest.reactivateAndCommit(db.getSession(), user, NewUser.builder() .setLogin(user.getLogin()) .setName(user.getName()) .build(), u -> { }); session.commit(); UserDto dto = dbClient.userDao().selectByUuid(session, user.getUuid()); assertThat(dto.isLocal()).isTrue(); assertThat(dto.getExternalId()).isEqualTo(user.getLogin()); assertThat(dto.getExternalLogin()).isEqualTo(user.getLogin()); assertThat(dto.getExternalIdentityProvider()).isEqualTo("sonarqube"); }
@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()); }
@Test public void reactivate_user_using_same_external_info_but_was_local() { UserDto user = db.users().insertDisabledUser(u -> u.setLocal(true) .setExternalId("ABCD") .setExternalLogin("john") .setExternalIdentityProvider("github")); createDefaultGroup(); underTest.reactivateAndCommit(db.getSession(), user, NewUser.builder() .setLogin(user.getLogin()) .setName(user.getName()) .setExternalIdentity(new ExternalIdentity("github", "john", "ABCD")) .build(), u -> { }); session.commit(); UserDto dto = dbClient.userDao().selectByUuid(session, user.getUuid()); assertThat(dto.isLocal()).isFalse(); assertThat(dto.getExternalId()).isEqualTo("ABCD"); assertThat(dto.getExternalLogin()).isEqualTo("john"); assertThat(dto.getExternalIdentityProvider()).isEqualTo("github"); }
@Test public void update_personal_organization_when_updating_login() { userSession.logIn().setSystemAdministrator(); String oldLogin = "old_login"; OrganizationDto personalOrganization = db.organizations().insert(o -> o.setKey(oldLogin).setGuarded(true)); UserDto user = db.users().insertUser(u -> u.setLogin(oldLogin).setOrganizationUuid(personalOrganization.getUuid())); ws.newRequest() .setParam("login", oldLogin) .setParam("newLogin", "new_login") .execute(); UserDto userReloaded = db.getDbClient().userDao().selectByUuid(db.getSession(), user.getUuid()); assertThat(userReloaded.getLogin()).isEqualTo("new_login"); OrganizationDto organizationReloaded = db.getDbClient().organizationDao().selectByUuid(db.getSession(), personalOrganization.getUuid()).get(); assertThat(organizationReloaded.getKey()).isEqualTo("new_login"); }
@Test public void submit_returns_task_populated_from_CeTaskSubmit_and_creates_CeQueue_row() { CeTaskSubmit taskSubmit = createTaskSubmit(CeTaskTypes.REPORT, newProjectDto("PROJECT_1"), "rob"); CeTask task = underTest.submit(taskSubmit); UserDto userDto = db.getDbClient().userDao().selectByUuid(db.getSession(), taskSubmit.getSubmitterUuid()); verifyCeTask(taskSubmit, task, null, userDto); verifyCeQueueDtoForTaskSubmit(taskSubmit); }
@Test public void submit_returns_task_populated_from_CeTaskSubmit_and_creates_CeQueue_row() { String componentUuid = randomAlphabetic(3); String mainComponentUuid = randomAlphabetic(4); CeTaskSubmit taskSubmit = createTaskSubmit(CeTaskTypes.REPORT, new Component(componentUuid, mainComponentUuid), "submitter uuid"); UserDto userDto = db.getDbClient().userDao().selectByUuid(db.getSession(), taskSubmit.getSubmitterUuid()); CeTask task = underTest.submit(taskSubmit); verifyCeTask(taskSubmit, task, null, userDto); verifyCeQueueDtoForTaskSubmit(taskSubmit); }
@Test public void authenticate_and_update_existing_user_matching_external_login() { UserDto user = db.users().insertUser(u -> u .setLogin("Old login") .setName("Old name") .setEmail(USER_IDENTITY.getEmail()) .setExternalId("Old id") .setExternalLogin(USER_IDENTITY.getProviderLogin()) .setExternalIdentityProvider(IDENTITY_PROVIDER.getKey())); underTest.register(UserRegistration.builder() .setUserIdentity(USER_IDENTITY) .setProvider(IDENTITY_PROVIDER) .setSource(Source.local(BASIC)) .setExistingEmailStrategy(ExistingEmailStrategy.FORBID) .setUpdateLoginStrategy(UpdateLoginStrategy.ALLOW) .build()); assertThat(db.users().selectUserByLogin("Old login")).isNotPresent(); assertThat(db.getDbClient().userDao().selectByUuid(db.getSession(), user.getUuid())) .extracting(UserDto::getLogin, UserDto::getName, UserDto::getEmail, UserDto::getExternalId, UserDto::getExternalLogin, UserDto::getExternalIdentityProvider, UserDto::isActive) .contains(USER_LOGIN, "John", "john@email.com", "ABCD", "johndoo", "github", true); }
@Test public void authenticate_existing_user_with_login_update_and_strategy_is_ALLOW() { UserDto user = db.users().insertUser(u -> u .setLogin("Old login") .setExternalId(USER_IDENTITY.getProviderId()) .setExternalLogin("old identity") .setExternalIdentityProvider(IDENTITY_PROVIDER.getKey())); underTest.register(UserRegistration.builder() .setUserIdentity(USER_IDENTITY) .setProvider(IDENTITY_PROVIDER) .setSource(Source.local(BASIC)) .setExistingEmailStrategy(ExistingEmailStrategy.FORBID) .setUpdateLoginStrategy(UpdateLoginStrategy.ALLOW) .build()); assertThat(db.getDbClient().userDao().selectByUuid(db.getSession(), user.getUuid())) .extracting(UserDto::getLogin, UserDto::getExternalLogin) .contains(USER_LOGIN, USER_IDENTITY.getProviderLogin()); }