"CREATED_AT" BIGINT,
"UPDATED_AT" BIGINT,
"HOMEPAGE_TYPE" VARCHAR(40),
- "HOMEPAGE_VALUE" VARCHAR(40)
+ "HOMEPAGE_PARAMETER" VARCHAR(40)
);
CREATE UNIQUE INDEX "USERS_LOGIN" ON "USERS" ("LOGIN");
CREATE INDEX "USERS_UPDATED_AT" ON "USERS" ("UPDATED_AT");
private Long createdAt;
private Long updatedAt;
private String homepageType;
- private String homepageValue;
+ private String homepageParameter;
private boolean local = true;
private boolean root = false;
private boolean onboarded = false;
}
@CheckForNull
- public String getHomepageValue() {
- return homepageValue;
+ public String getHomepageParameter() {
+ return homepageParameter;
}
- public UserDto setHomepageValue(@Nullable String homepageValue) {
- this.homepageValue = homepageValue;
+ public UserDto setHomepageParameter(@Nullable String homepageParameter) {
+ this.homepageParameter = homepageParameter;
return this;
}
void deactivateUser(@Param("login") String login, @Param("now") long now);
- void clearHomepage(@Param("homepageType") String type, @Param("homepageValue") String value, @Param("now") long now);
+ void clearHomepage(@Param("homepageType") String type, @Param("homepageParameter") String value, @Param("now") long now);
}
u.created_at as "createdAt",
u.updated_at as "updatedAt",
u.homepage_type as "homepageType",
- u.homepage_value as "homepageValue"
+ u.homepage_parameter as "homepageParameter"
</sql>
<select id="selectByLogin" parameterType="String" resultType="User">
<update id="clearHomepage" parameterType="map">
update users set
homepage_type = null,
- homepage_value = null,
+ homepage_parameter = null,
updated_at = #{now, jdbcType=BIGINT}
where
homepage_type = #{homepageType, jdbcType=VARCHAR}
- and homepage_value = #{homepageValue, jdbcType=VARCHAR}
+ and homepage_parameter = #{homepageParameter, jdbcType=VARCHAR}
</update>
<update id="setRoot">
created_at,
updated_at,
homepage_type,
- homepage_value
+ homepage_parameter
) values (
#{user.login,jdbcType=VARCHAR},
#{user.name,jdbcType=VARCHAR},
#{now,jdbcType=BIGINT},
#{now,jdbcType=BIGINT},
#{user.homepageType,jdbcType=VARCHAR},
- #{user.homepageValue,jdbcType=VARCHAR}
+ #{user.homepageParameter,jdbcType=VARCHAR}
)
</insert>
crypted_password = #{user.cryptedPassword, jdbcType=BIGINT},
updated_at = #{now, jdbcType=BIGINT},
homepage_type = #{user.homepageType, jdbcType=VARCHAR},
- homepage_value = #{user.homepageValue, jdbcType=VARCHAR}
+ homepage_parameter = #{user.homepageParameter, jdbcType=VARCHAR}
where
login = #{user.login, jdbcType=VARCHAR}
</update>
.setCreatedAt(date)
.setUpdatedAt(date)
.setHomepageType("project")
- .setHomepageValue("OB1");
+ .setHomepageParameter("OB1");
underTest.insert(db.getSession(), userDto);
db.getSession().commit();
assertThat(user.isLocal()).isTrue();
assertThat(user.isRoot()).isFalse();
assertThat(user.getHomepageType()).isEqualTo("project");
- assertThat(user.getHomepageValue()).isEqualTo("OB1");
+ assertThat(user.getHomepageParameter()).isEqualTo("OB1");
}
@Test
.setExternalIdentityProvider("github")
.setLocal(false)
.setHomepageType("project")
- .setHomepageValue("OB1");
+ .setHomepageParameter("OB1");
underTest.update(db.getSession(), userUpdate);
UserDto reloaded = underTest.selectByLogin(db.getSession(), user.getLogin());
assertThat(reloaded.isLocal()).isFalse();
assertThat(reloaded.isRoot()).isFalse();
assertThat(reloaded.getHomepageType()).isEqualTo("project");
- assertThat(reloaded.getHomepageValue()).isEqualTo("OB1");
+ assertThat(reloaded.getHomepageParameter()).isEqualTo("OB1");
}
@Test
assertThat(userReloaded.isRoot()).isFalse();
assertThat(userReloaded.getUpdatedAt()).isEqualTo(NOW);
assertThat(userReloaded.getHomepageType()).isNull();
- assertThat(userReloaded.getHomepageValue()).isNull();
+ assertThat(userReloaded.getHomepageParameter()).isNull();
assertThat(underTest.selectUserById(session, otherUser.getId())).isNotNull();
}
@Test
public void clean_users_homepage_when_deleting_organization() {
- UserDto userUnderTest = newUserDto().setHomepageType("ORGANIZATION").setHomepageValue("dummy-organization-UUID");
+ UserDto userUnderTest = newUserDto().setHomepageType("ORGANIZATION").setHomepageParameter("dummy-organization-UUID");
underTest.insert(session, userUnderTest);
- UserDto untouchedUser = newUserDto().setHomepageType("ORGANIZATION").setHomepageValue("not-so-dummy-organization-UUID");
+ UserDto untouchedUser = newUserDto().setHomepageType("ORGANIZATION").setHomepageParameter("not-so-dummy-organization-UUID");
underTest.insert(session, untouchedUser);
session.commit();
UserDto userWithAHomepageReloaded = underTest.selectUserById(session, userUnderTest.getId());
assertThat(userWithAHomepageReloaded.getUpdatedAt()).isEqualTo(NOW);
assertThat(userWithAHomepageReloaded.getHomepageType()).isNull();
- assertThat(userWithAHomepageReloaded.getHomepageValue()).isNull();
+ assertThat(userWithAHomepageReloaded.getHomepageParameter()).isNull();
UserDto untouchedUserReloaded = underTest.selectUserById(session, untouchedUser.getId());
assertThat(untouchedUserReloaded.getUpdatedAt()).isEqualTo(untouchedUser.getUpdatedAt());
assertThat(untouchedUserReloaded.getHomepageType()).isEqualTo(untouchedUser.getHomepageType());
- assertThat(untouchedUserReloaded.getHomepageValue()).isEqualTo(untouchedUser.getHomepageValue());
+ assertThat(untouchedUserReloaded.getHomepageParameter()).isEqualTo(untouchedUser.getHomepageParameter());
}
@Test
public void clean_users_homepage_when_deleting_project() {
- UserDto userUnderTest = newUserDto().setHomepageType("PROJECT").setHomepageValue("dummy-project-UUID");
+ UserDto userUnderTest = newUserDto().setHomepageType("PROJECT").setHomepageParameter("dummy-project-UUID");
underTest.insert(session, userUnderTest);
- UserDto untouchedUser = newUserDto().setHomepageType("PROJECT").setHomepageValue("not-so-dummy-project-UUID");
+ UserDto untouchedUser = newUserDto().setHomepageType("PROJECT").setHomepageParameter("not-so-dummy-project-UUID");
underTest.insert(session, untouchedUser);
session.commit();
UserDto userWithAHomepageReloaded = underTest.selectUserById(session, userUnderTest.getId());
assertThat(userWithAHomepageReloaded.getUpdatedAt()).isEqualTo(NOW);
assertThat(userWithAHomepageReloaded.getHomepageType()).isNull();
- assertThat(userWithAHomepageReloaded.getHomepageValue()).isNull();
+ assertThat(userWithAHomepageReloaded.getHomepageParameter()).isNull();
UserDto untouchedUserReloaded = underTest.selectUserById(session, untouchedUser.getId());
assertThat(untouchedUserReloaded.getUpdatedAt()).isEqualTo(untouchedUser.getUpdatedAt());
assertThat(untouchedUserReloaded.getHomepageType()).isEqualTo(untouchedUser.getHomepageType());
- assertThat(untouchedUserReloaded.getHomepageValue()).isEqualTo(untouchedUser.getHomepageValue());
+ assertThat(untouchedUserReloaded.getHomepageParameter()).isEqualTo(untouchedUser.getHomepageParameter());
}
@Test
.setSalt("79bd6a8e79fb8c76ac8b121cc7e8e11ad1af8365")
.setCryptedPassword("650d2261c98361e2f67f90ce5c65a95e7d8ea2fg")
.setHomepageType("project")
- .setHomepageValue("OB1"));
+ .setHomepageParameter("OB1"));
UserDto user2 = db.users().insertUser();
underTest.setRoot(session, user2.getLogin(), true);
assertThat(dto.getCreatedAt()).isEqualTo(user1.getCreatedAt());
assertThat(dto.getUpdatedAt()).isEqualTo(user1.getUpdatedAt());
assertThat(dto.getHomepageType()).isEqualTo("project");
- assertThat(dto.getHomepageValue()).isEqualTo("OB1");
+ assertThat(dto.getHomepageParameter()).isEqualTo("OB1");
dto = underTest.selectOrFailByLogin(session, user2.getLogin());
assertThat(dto.isRoot()).isTrue();
.setLimit(40)
.build())
.addColumn(newVarcharColumnDefBuilder()
- .setColumnName("homepage_value")
+ .setColumnName("homepage_parameter")
.setIsNullable(true)
.setLimit(40)
.build())
.add(1920, "Read 'sonar.qualitygate' setting and set the value to default organization", ReadGlobalSonarQualityGateSettingToDefaultOrg.class)
.add(1921, "Delete 'sonar.qualitygate' setting at global level", DeleteGlobalSonarQualityGateSetting.class)
.add(1922, "Make ORGANIZATIONS.DEFAULT_QUALITY_GATE_UUID not nullable", SetDefaultQualityGateUuidAsNotNullableInOrganizations.class)
- .add(1923, "Add users.homepage_type and users.homepage_value", AddHomepageToUsers.class)
+ .add(1923, "Add users.homepage_type and users.homepage_parameter", AddHomepageToUsers.class)
;
}
}
underTest.execute();
dbTester.assertColumnDefinition("users", "homepage_type", VARCHAR, 40, true);
- dbTester.assertColumnDefinition("users", "homepage_value", VARCHAR, 40, true);
+ dbTester.assertColumnDefinition("users", "homepage_parameter", VARCHAR, 40, true);
}
@Test
if (user.getHomepageType() == null) {
return defaultHomepageOf();
}
- String homepageValue = getHomepageValue(dbSession, user.getHomepageType(), user.getHomepageValue());
+ String homepageParameter = getHomepageParameter(dbSession, user.getHomepageType(), user.getHomepageParameter());
CurrentWsResponse.Homepage.Builder homepage = CurrentWsResponse.Homepage.newBuilder()
.setType(CurrentWsResponse.HomepageType.valueOf(user.getHomepageType()));
- setNullable(homepageValue, homepage::setValue);
+ setNullable(homepageParameter, homepage::setParameter);
return homepage.build();
}
@CheckForNull
- private String getHomepageValue(DbSession dbSession, String homepageType, String homepageValue) {
+ private String getHomepageParameter(DbSession dbSession, String homepageType, String homepageParameter) {
if (PROJECT.toString().equals(homepageType)) {
- return dbClient.componentDao().selectByUuid(dbSession, homepageValue)
+ return dbClient.componentDao().selectByUuid(dbSession, homepageParameter)
.transform(ComponentDto::getKey)
.or(() -> {
- throw new IllegalStateException(format("Unknown component '%s' for homepageValue", homepageValue));
+ throw new IllegalStateException(format("Unknown component '%s' for homepageParameter", homepageParameter));
});
}
if (ORGANIZATION.toString().equals(homepageType)) {
- return dbClient.organizationDao().selectByUuid(dbSession, homepageValue)
+ return dbClient.organizationDao().selectByUuid(dbSession, homepageParameter)
.map(OrganizationDto::getKey)
- .orElseThrow(() -> new IllegalStateException(format("Unknown organization '%s' for homepageValue", homepageValue)));
+ .orElseThrow(() -> new IllegalStateException(format("Unknown organization '%s' for homepageParameter", homepageParameter)));
}
return null;
}
- // Default WIP implementation to be done in SONAR-10185
private static CurrentWsResponse.Homepage defaultHomepageOf() {
return CurrentWsResponse.Homepage.newBuilder()
.setType(MY_PROJECTS)
public class SetHomepageAction implements UsersWsAction {
static final String PARAM_TYPE = "type";
- static final String PARAM_VALUE = "value";
+ static final String PARAM_PARAMETER = "parameter";
static final String ACTION = "set_homepage";
private final UserSession userSession;
.setRequired(true)
.setPossibleValues(HomepageTypes.keys());
- action.createParam(PARAM_VALUE)
+ action.createParam(PARAM_PARAMETER)
.setDescription("Additional information to identify the page (project or organization key)")
.setExampleValue(KEY_PROJECT_EXAMPLE_001);
userSession.checkLoggedIn();
String type = request.mandatoryParam(PARAM_TYPE);
- String value = request.param(PARAM_VALUE);
+ String parameter = request.param(PARAM_PARAMETER);
- checkRequest(type, value);
+ checkRequest(type, parameter);
String login = userSession.getLogin();
checkState(user != null, "User login '%s' cannot be found", login);
user.setHomepageType(type);
- user.setHomepageValue(findHomepageValue(dbSession, type, value));
+ user.setHomepageParameter(findHomepageParameter(dbSession, type, parameter));
dbClient.userDao().update(dbSession, user);
dbSession.commit();
}
@CheckForNull
- private String findHomepageValue(DbSession dbSession, String type, String value) {
+ private String findHomepageParameter(DbSession dbSession, String type, String parameter) {
if (PROJECT.toString().equals(type)) {
- return componentFinder.getByKey(dbSession, value).uuid();
+ return componentFinder.getByKey(dbSession, parameter).uuid();
}
if (ORGANIZATION.toString().equals(type)) {
- return checkFoundWithOptional(dbClient.organizationDao().selectByKey(dbSession, value), "No organizationDto with key '%s'", value).getUuid();
+ return checkFoundWithOptional(dbClient.organizationDao().selectByKey(dbSession, parameter), "No organizationDto with key '%s'", parameter).getUuid();
}
return null;
}
- private static void checkRequest(String type, @Nullable String value) {
+ private static void checkRequest(String type, @Nullable String parameter) {
if (PROJECT.toString().equals(type) || ORGANIZATION.toString().equals(type)) {
- checkArgument(isNotBlank(value), "Type %s requires a value", type);
+ checkArgument(isNotBlank(parameter), "Type %s requires a parameter", type);
}
if (MY_PROJECTS.toString().equals(type) || MY_ISSUES.toString().equals(type)) {
- checkArgument(isBlank(value), "Parameter value must not be provided when type is %s", type);
+ checkArgument(isBlank(parameter), "Parameter parameter must not be provided when type is %s", type);
}
}
},
"homepage": {
"type": "PROJECT",
- "value": "death-star-key"
+ "parameter": "death-star-key"
}
}
@Test
public void organization_deletion_also_ensure_that_homepage_on_this_organization_if_it_exists_is_cleared() throws Exception {
OrganizationDto organization = db.organizations().insert();
- UserDto user = dbClient.userDao().insert(session, newUserDto().setHomepageType("ORGANIZATION").setHomepageValue(organization.getUuid()));
+ UserDto user = dbClient.userDao().insert(session, newUserDto().setHomepageType("ORGANIZATION").setHomepageParameter(organization.getUuid()));
session.commit();
userSession.logIn().addPermission(ADMINISTER, organization);
UserDto userReloaded = dbClient.userDao().selectUserById(session, user.getId());
assertThat(userReloaded.getHomepageType()).isNull();
- assertThat(userReloaded.getHomepageValue()).isNull();
+ assertThat(userReloaded.getHomepageParameter()).isNull();
}
@Test
OrganizationDto organization = db.organizations().insert();
ComponentDto project = db.components().insertPrivateProject(organization);
UserDto user = dbClient.userDao().insert(session,
- newUserDto().setHomepageType("PROJECT").setHomepageValue(project.uuid()));
+ newUserDto().setHomepageType("PROJECT").setHomepageParameter(project.uuid()));
session.commit();
userSession.logIn().addPermission(ADMINISTER, organization);
UserDto userReloaded = dbClient.userDao().selectUserById(session, user.getId());
assertThat(userReloaded.getHomepageType()).isNull();
- assertThat(userReloaded.getHomepageValue()).isNull();
+ assertThat(userReloaded.getHomepageParameter()).isNull();
}
@Test
ComponentDto project = componentDbTester.insertPrivateProject();
UserDto insert = dbClient.userDao().insert(dbSession,
- newUserDto().setHomepageType("PROJECT").setHomepageValue(project.uuid()));
+ newUserDto().setHomepageType("PROJECT").setHomepageParameter(project.uuid()));
dbSession.commit();
userSessionRule.logIn().addProjectPermission(ADMIN, project);
UserDto userReloaded = dbClient.userDao().selectUserById(dbSession, insert.getId());
assertThat(userReloaded.getHomepageType()).isNull();
- assertThat(userReloaded.getHomepageValue()).isNull();
+ assertThat(userReloaded.getHomepageParameter()).isNull();
}
@Test
import org.sonar.api.utils.System2;
import org.sonar.db.DbClient;
import org.sonar.db.DbTester;
-import org.sonar.db.component.ComponentDto;
import org.sonar.db.user.UserDto;
import org.sonar.server.issue.ws.AvatarResolverImpl;
import org.sonar.server.organization.DefaultOrganizationProvider;
.setScmAccounts(newArrayList("obiwan:github", "obiwan:bitbucket"))
.setOnboarded(true)
.setHomepageType("PROJECT")
- .setHomepageValue("UUID-of-the-death-star"));
+ .setHomepageParameter("UUID-of-the-death-star"));
db.users().insertMember(db.users().insertGroup(newGroupDto().setName("Jedi")), obiwan);
db.users().insertMember(db.users().insertGroup(newGroupDto().setName("Rebel")), obiwan);
@Test
public void fail_with_ISE_when_user_homepage_project_does_not_exist_in_db() {
- UserDto user = db.users().insertUser(u -> u.setHomepageType("PROJECT").setHomepageValue("not-existing-project-uuid"));
+ UserDto user = db.users().insertUser(u -> u.setHomepageType("PROJECT").setHomepageParameter("not-existing-project-uuid"));
userSessionRule.logIn(user.getLogin());
expectedException.expect(IllegalStateException.class);
- expectedException.expectMessage("Unknown component 'not-existing-project-uuid' for homepageValue");
+ expectedException.expectMessage("Unknown component 'not-existing-project-uuid' for homepageParameter");
call();
}
@Test
public void fail_with_ISE_when_user_homepage_organization_does_not_exist_in_db() {
- UserDto user = db.users().insertUser(u -> u.setHomepageType("ORGANIZATION").setHomepageValue("not-existing-organization-uuid"));
+ UserDto user = db.users().insertUser(u -> u.setHomepageType("ORGANIZATION").setHomepageParameter("not-existing-organization-uuid"));
userSessionRule.logIn(user.getLogin());
expectedException.expect(IllegalStateException.class);
- expectedException.expectMessage("Unknown organization 'not-existing-organization-uuid' for homepageValue");
+ expectedException.expectMessage("Unknown organization 'not-existing-organization-uuid' for homepageParameter");
call();
}
import static org.apache.http.HttpStatus.SC_NO_CONTENT;
import static org.assertj.core.api.Assertions.assertThat;
import static org.sonar.db.component.ComponentTesting.newPrivateProjectDto;
+import static org.sonar.server.user.ws.SetHomepageAction.PARAM_PARAMETER;
import static org.sonar.server.user.ws.SetHomepageAction.PARAM_TYPE;
-import static org.sonar.server.user.ws.SetHomepageAction.PARAM_VALUE;
import static org.sonarqube.ws.Users.CurrentWsResponse.HomepageType.MY_ISSUES;
import static org.sonarqube.ws.Users.CurrentWsResponse.HomepageType.MY_PROJECTS;
import static org.sonarqube.ws.Users.CurrentWsResponse.HomepageType.ORGANIZATION;
assertThat(typeParam.deprecatedSince()).isNull();
assertThat(typeParam.deprecatedKey()).isNull();
- WebService.Param keyParam = action.param("value");
+ WebService.Param keyParam = action.param("parameter");
assertThat(keyParam.isRequired()).isFalse();
assertThat(keyParam.description()).isEqualTo("Additional information to identify the page (project or organization key)");
assertThat(keyParam.exampleValue()).isEqualTo("my_project");
ws.newRequest()
.setMethod("POST")
.setParam(PARAM_TYPE, PROJECT.toString())
- .setParam(PARAM_VALUE, project.getKey())
+ .setParam(PARAM_PARAMETER, project.getKey())
.execute();
UserDto actual = db.getDbClient().userDao().selectByLogin(db.getSession(), user.getLogin());
assertThat(actual).isNotNull();
assertThat(actual.getHomepageType()).isEqualTo(PROJECT.toString());
- assertThat(actual.getHomepageValue()).isEqualTo(project.uuid());
+ assertThat(actual.getHomepageParameter()).isEqualTo(project.uuid());
}
@Test
ws.newRequest()
.setMethod("POST")
.setParam(PARAM_TYPE, ORGANIZATION.toString())
- .setParam(PARAM_VALUE, organization.getKey())
+ .setParam(PARAM_PARAMETER, organization.getKey())
.execute();
UserDto actual = db.getDbClient().userDao().selectByLogin(db.getSession(), user.getLogin());
assertThat(actual).isNotNull();
assertThat(actual.getHomepageType()).isEqualTo(ORGANIZATION.toString());
- assertThat(actual.getHomepageValue()).isEqualTo(organization.getUuid());
+ assertThat(actual.getHomepageParameter()).isEqualTo(organization.getUuid());
}
@Test
UserDto actual = db.getDbClient().userDao().selectByLogin(db.getSession(), user.getLogin());
assertThat(actual).isNotNull();
assertThat(actual.getHomepageType()).isEqualTo(MY_ISSUES.toString());
- assertThat(actual.getHomepageValue()).isNullOrEmpty();
+ assertThat(actual.getHomepageParameter()).isNullOrEmpty();
}
@Test
UserDto actual = db.getDbClient().userDao().selectByLogin(db.getSession(), user.getLogin());
assertThat(actual).isNotNull();
assertThat(actual.getHomepageType()).isEqualTo(MY_PROJECTS.toString());
- assertThat(actual.getHomepageValue()).isNullOrEmpty();
+ assertThat(actual.getHomepageParameter()).isNullOrEmpty();
}
@Test
public void fail_when_missing_project_id_when_requesting_project_type() {
expectedException.expect(IllegalArgumentException.class);
- expectedException.expectMessage("Type PROJECT requires a value");
+ expectedException.expectMessage("Type PROJECT requires a parameter");
UserDto user = db.users().insertUser();
userSession.logIn(user);
ws.newRequest()
.setMethod("POST")
.setParam(PARAM_TYPE, PROJECT.toString())
- .setParam(PARAM_VALUE, "")
+ .setParam(PARAM_PARAMETER, "")
.execute();
}
public void fail_when_missing_organization_id_when_requesting_organization_type() {
expectedException.expect(IllegalArgumentException.class);
- expectedException.expectMessage("Type ORGANIZATION requires a value");
+ expectedException.expectMessage("Type ORGANIZATION requires a parameter");
UserDto user = db.users().insertUser();
userSession.logIn(user);
ws.newRequest()
.setMethod("POST")
.setParam(PARAM_TYPE, ORGANIZATION.toString())
- .setParam(PARAM_VALUE, "")
+ .setParam(PARAM_PARAMETER, "")
.execute();
}
message Homepage {
optional HomepageType type = 1;
- optional string value = 2;
+ optional string parameter = 2;
}
}