@@ -20,6 +20,7 @@ | |||
package org.sonar.ce.task.projectanalysis.component; | |||
import org.apache.commons.lang.StringUtils; | |||
import org.sonar.api.resources.Qualifiers; | |||
import org.sonar.api.utils.System2; | |||
import org.sonar.db.DbClient; | |||
import org.sonar.db.DbSession; | |||
@@ -69,6 +70,8 @@ public class ProjectPersister { | |||
projectDto.setName(root.getName()); | |||
projectDto.setDescription(root.getDescription()); | |||
projectDto.setUpdatedAt(system2.now()); | |||
projectDto.setKey(root.getKey()); | |||
projectDto.setQualifier(root.getType().equals(Component.Type.PROJECT) ? Qualifiers.PROJECT : Qualifiers.APP); | |||
return projectDto; | |||
} | |||
} |
@@ -52,7 +52,6 @@ import org.sonar.db.component.ComponentUpdateDto; | |||
import static java.util.Optional.ofNullable; | |||
import static org.sonar.api.resources.Qualifiers.PROJECT; | |||
import static org.sonar.api.resources.Qualifiers.VIEW; | |||
import static org.sonar.ce.task.projectanalysis.component.ComponentVisitor.Order.PRE_ORDER; | |||
import static org.sonar.db.component.ComponentDto.UUID_PATH_OF_ROOT; | |||
import static org.sonar.db.component.ComponentDto.UUID_PATH_SEPARATOR; | |||
@@ -108,8 +107,7 @@ public class PersistComponentsStep implements ComputationStep { | |||
.visit(treeRootHolder.getRoot()); | |||
disableRemainingComponents(dbSession, existingDtosByUuids.values()); | |||
ensureConsistentVisibility(dbSession, projectUuid, isRootPrivate, treeRootHolder.getRoot().getType(), treeRootHolder.getRoot().getName()); | |||
dbClient.componentDao().setPrivateForRootComponentUuidWithoutAudit(dbSession, projectUuid, isRootPrivate); | |||
dbSession.commit(); | |||
} | |||
} | |||
@@ -135,18 +133,6 @@ public class PersistComponentsStep implements ComputationStep { | |||
disabledComponentsHolder.setUuids(uuids); | |||
} | |||
private void ensureConsistentVisibility(DbSession dbSession, String projectUuid, boolean isRootPrivate, | |||
Component.Type type, String componentName) { | |||
String qualifier = null; | |||
if (type == Component.Type.PROJECT) { | |||
qualifier = PROJECT; | |||
} else if (type == Component.Type.VIEW) { | |||
qualifier = VIEW; | |||
} | |||
dbClient.componentDao().setPrivateForRootComponentUuid(dbSession, projectUuid, isRootPrivate, | |||
"", qualifier, componentName, false); | |||
} | |||
private static boolean isRootPrivate(Component root, Map<String, ComponentDto> existingDtosByUuids) { | |||
ComponentDto rootDto = existingDtosByUuids.get(root.getUuid()); | |||
if (rootDto == null) { |
@@ -83,6 +83,8 @@ import org.sonar.db.DaoModule; | |||
import org.sonar.db.DbClient; | |||
import org.sonar.db.DefaultDatabase; | |||
import org.sonar.db.MyBatis; | |||
import org.sonar.db.audit.AuditPersister; | |||
import org.sonar.db.audit.NoOpAuditPersister; | |||
import org.sonar.db.purge.PurgeProfiler; | |||
import org.sonar.process.NetworkUtilsImpl; | |||
import org.sonar.process.Props; | |||
@@ -203,6 +205,9 @@ public class ComputeEngineContainerImpl implements ComputeEngineContainer { | |||
level1.getComponentByType(CECoreExtensionsInstaller.class) | |||
.install(level1, hasPlatformLevel(1), noAdditionalSideFilter()); | |||
if (level1.getComponentByType(AuditPersister.class) == null) { | |||
level1.add(NoOpAuditPersister.class); | |||
} | |||
level1.startComponents(); | |||
} | |||
@@ -25,6 +25,7 @@ import org.sonar.api.utils.System2; | |||
import org.sonar.core.util.UuidFactory; | |||
import org.sonar.db.DbSession; | |||
import org.sonar.db.MyBatis; | |||
import org.sonar.db.audit.NoOpAuditPersister; | |||
import org.sonar.db.property.PropertiesDao; | |||
import org.sonar.db.property.PropertyDto; | |||
@@ -39,7 +40,7 @@ import org.sonar.db.property.PropertyDto; | |||
*/ | |||
public class ReadOnlyPropertiesDao extends PropertiesDao { | |||
public ReadOnlyPropertiesDao(MyBatis mybatis, System2 system2, UuidFactory uuidFactory) { | |||
super(mybatis, system2, uuidFactory); | |||
super(mybatis, system2, uuidFactory, new NoOpAuditPersister()); | |||
} | |||
@Override |
@@ -34,12 +34,7 @@ public class AlmPatDao implements Dao { | |||
private final System2 system2; | |||
private final UuidFactory uuidFactory; | |||
private AuditPersister auditPersister; | |||
public AlmPatDao(System2 system2, UuidFactory uuidFactory) { | |||
this.system2 = system2; | |||
this.uuidFactory = uuidFactory; | |||
} | |||
private final AuditPersister auditPersister; | |||
public AlmPatDao(System2 system2, UuidFactory uuidFactory, AuditPersister auditPersister) { | |||
this.system2 = system2; | |||
@@ -67,37 +62,33 @@ public class AlmPatDao implements Dao { | |||
almPatDto.setUpdatedAt(now); | |||
getMapper(dbSession).insert(almPatDto); | |||
if (auditPersister != null) { | |||
auditPersister.addPersonalAccessToken(dbSession, new PersonalAccessTokenNewValue(almPatDto, userLogin, almSettingKey)); | |||
} | |||
auditPersister.addPersonalAccessToken(dbSession, new PersonalAccessTokenNewValue(almPatDto, userLogin, almSettingKey)); | |||
} | |||
public void update(DbSession dbSession, AlmPatDto almPatDto, @Nullable String userLogin, @Nullable String almSettingKey) { | |||
long now = system2.now(); | |||
almPatDto.setUpdatedAt(now); | |||
getMapper(dbSession).update(almPatDto); | |||
if (auditPersister != null) { | |||
auditPersister.updatePersonalAccessToken(dbSession, new PersonalAccessTokenNewValue(almPatDto, userLogin, almSettingKey)); | |||
} | |||
auditPersister.updatePersonalAccessToken(dbSession, new PersonalAccessTokenNewValue(almPatDto, userLogin, almSettingKey)); | |||
} | |||
public void delete(DbSession dbSession, AlmPatDto almPatDto, @Nullable String userLogin, @Nullable String almSettingKey) { | |||
int deletedRows = getMapper(dbSession).deleteByUuid(almPatDto.getUuid()); | |||
if (deletedRows > 0 && auditPersister != null) { | |||
if (deletedRows > 0) { | |||
auditPersister.deletePersonalAccessToken(dbSession, new PersonalAccessTokenNewValue(almPatDto, userLogin, almSettingKey)); | |||
} | |||
} | |||
public void deleteByUser(DbSession dbSession, UserDto user) { | |||
int deletedRows = getMapper(dbSession).deleteByUser(user.getUuid()); | |||
if (deletedRows > 0 && auditPersister != null) { | |||
if (deletedRows > 0) { | |||
auditPersister.deletePersonalAccessToken(dbSession, new PersonalAccessTokenNewValue(user)); | |||
} | |||
} | |||
public void deleteByAlmSetting(DbSession dbSession, AlmSettingDto almSetting) { | |||
int deletedRows = getMapper(dbSession).deleteByAlmSetting(almSetting.getUuid()); | |||
if (deletedRows > 0 && auditPersister != null) { | |||
if (deletedRows > 0) { | |||
auditPersister.deletePersonalAccessToken(dbSession, new PersonalAccessTokenNewValue(almSetting)); | |||
} | |||
} |
@@ -33,16 +33,11 @@ public class AlmSettingDao implements Dao { | |||
private final System2 system2; | |||
private final UuidFactory uuidFactory; | |||
private final AuditPersister auditPersister; | |||
private AuditPersister auditPersister; | |||
public AlmSettingDao(System2 system2, UuidFactory uuidFactory) { | |||
public AlmSettingDao(System2 system2, UuidFactory uuidFactory, AuditPersister auditPersister) { | |||
this.system2 = system2; | |||
this.uuidFactory = uuidFactory; | |||
} | |||
public AlmSettingDao(System2 system2, UuidFactory uuidFactory, AuditPersister auditPersister) { | |||
this(system2, uuidFactory); | |||
this.auditPersister = auditPersister; | |||
} | |||
@@ -58,9 +53,7 @@ public class AlmSettingDao implements Dao { | |||
almSettingDto.setUpdatedAt(now); | |||
getMapper(dbSession).insert(almSettingDto); | |||
if (auditPersister != null) { | |||
auditPersister.addDevOpsPlatformSetting(dbSession, new DevOpsPlatformSettingNewValue(almSettingDto)); | |||
} | |||
auditPersister.addDevOpsPlatformSetting(dbSession, new DevOpsPlatformSettingNewValue(almSettingDto)); | |||
} | |||
public Optional<AlmSettingDto> selectByUuid(DbSession dbSession, String uuid) { | |||
@@ -82,7 +75,7 @@ public class AlmSettingDao implements Dao { | |||
public void delete(DbSession dbSession, AlmSettingDto almSettingDto) { | |||
int deletedRows = getMapper(dbSession).deleteByKey(almSettingDto.getKey()); | |||
if (deletedRows > 0 && auditPersister != null) { | |||
if (deletedRows > 0) { | |||
auditPersister.deleteDevOpsPlatformSetting(dbSession, new DevOpsPlatformSettingNewValue(almSettingDto.getUuid(), almSettingDto.getKey())); | |||
} | |||
} | |||
@@ -91,12 +84,9 @@ public class AlmSettingDao implements Dao { | |||
long now = system2.now(); | |||
almSettingDto.setUpdatedAt(now); | |||
getMapper(dbSession).update(almSettingDto); | |||
if (auditPersister != null) { | |||
if (updateSecret) { | |||
auditPersister.updateDevOpsPlatformSecret(dbSession, new SecretNewValue("DevOpsPlatform", almSettingDto.getRawAlm())); | |||
} | |||
auditPersister.updateDevOpsPlatformSetting(dbSession, new DevOpsPlatformSettingNewValue(almSettingDto)); | |||
if (updateSecret) { | |||
auditPersister.updateDevOpsPlatformSecret(dbSession, new SecretNewValue("DevOpsPlatform", almSettingDto.getRawAlm())); | |||
} | |||
auditPersister.updateDevOpsPlatformSetting(dbSession, new DevOpsPlatformSettingNewValue(almSettingDto)); | |||
} | |||
} |
@@ -36,20 +36,15 @@ public class ProjectAlmSettingDao implements Dao { | |||
private final System2 system2; | |||
private final UuidFactory uuidFactory; | |||
private AuditPersister auditPersister; | |||
private final AuditPersister auditPersister; | |||
public ProjectAlmSettingDao(System2 system2, UuidFactory uuidFactory) { | |||
public ProjectAlmSettingDao(System2 system2, UuidFactory uuidFactory, AuditPersister auditPersister) { | |||
this.system2 = system2; | |||
this.uuidFactory = uuidFactory; | |||
} | |||
public ProjectAlmSettingDao(System2 system2, UuidFactory uuidFactory, AuditPersister auditPersister) { | |||
this(system2, uuidFactory); | |||
this.auditPersister = auditPersister; | |||
} | |||
public void insertOrUpdate(DbSession dbSession, ProjectAlmSettingDto projectAlmSettingDto, String key, | |||
String projectName, String projectKey) { | |||
public void insertOrUpdate(DbSession dbSession, ProjectAlmSettingDto projectAlmSettingDto, String key, String projectName, String projectKey) { | |||
String uuid = uuidFactory.create(); | |||
long now = system2.now(); | |||
ProjectAlmSettingMapper mapper = getMapper(dbSession); | |||
@@ -63,21 +58,18 @@ public class ProjectAlmSettingDao implements Dao { | |||
} | |||
projectAlmSettingDto.setUpdatedAt(now); | |||
if (auditPersister != null) { | |||
DevOpsPlatformSettingNewValue value = new DevOpsPlatformSettingNewValue(projectAlmSettingDto, key, | |||
projectName, projectKey); | |||
if (isUpdate) { | |||
auditPersister.updateDevOpsPlatformSetting(dbSession, value); | |||
} else { | |||
auditPersister.addDevOpsPlatformSetting(dbSession, value); | |||
} | |||
DevOpsPlatformSettingNewValue value = new DevOpsPlatformSettingNewValue(projectAlmSettingDto, key, projectName, projectKey); | |||
if (isUpdate) { | |||
auditPersister.updateDevOpsPlatformSetting(dbSession, value); | |||
} else { | |||
auditPersister.addDevOpsPlatformSetting(dbSession, value); | |||
} | |||
} | |||
public void deleteByProject(DbSession dbSession, ProjectDto project) { | |||
int deletedRows = getMapper(dbSession).deleteByProjectUuid(project.getUuid()); | |||
if (deletedRows > 0 && auditPersister != null) { | |||
if (deletedRows > 0) { | |||
auditPersister.deleteDevOpsPlatformSetting(dbSession, new DevOpsPlatformSettingNewValue(project)); | |||
} | |||
} |
@@ -21,111 +21,123 @@ package org.sonar.db.audit; | |||
import org.sonar.core.extension.PlatformLevel; | |||
import org.sonar.db.DbSession; | |||
import org.sonar.db.audit.model.NewValue; | |||
import javax.annotation.Nullable; | |||
import org.sonar.db.audit.model.ComponentKeyNewValue; | |||
import org.sonar.db.audit.model.ComponentNewValue; | |||
import org.sonar.db.audit.model.DevOpsPlatformSettingNewValue; | |||
import org.sonar.db.audit.model.GroupPermissionNewValue; | |||
import org.sonar.db.audit.model.LicenseNewValue; | |||
import org.sonar.db.audit.model.PermissionTemplateNewValue; | |||
import org.sonar.db.audit.model.PersonalAccessTokenNewValue; | |||
import org.sonar.db.audit.model.PluginNewValue; | |||
import org.sonar.db.audit.model.PropertyNewValue; | |||
import org.sonar.db.audit.model.SecretNewValue; | |||
import org.sonar.db.audit.model.UserGroupNewValue; | |||
import org.sonar.db.audit.model.UserNewValue; | |||
import org.sonar.db.audit.model.UserPermissionNewValue; | |||
import org.sonar.db.audit.model.UserTokenNewValue; | |||
import org.sonar.db.audit.model.WebhookNewValue; | |||
@PlatformLevel(1) | |||
public interface AuditPersister { | |||
void addUserGroup(DbSession dbSession, NewValue newValue); | |||
void addUserGroup(DbSession dbSession, UserGroupNewValue newValue); | |||
void updateUserGroup(DbSession dbSession, NewValue newValue); | |||
void updateUserGroup(DbSession dbSession, UserGroupNewValue newValue); | |||
void deleteUserGroup(DbSession dbSession, NewValue newValue); | |||
void deleteUserGroup(DbSession dbSession, UserGroupNewValue newValue); | |||
void addUser(DbSession dbSession, NewValue newValue); | |||
void addUser(DbSession dbSession, UserNewValue newValue); | |||
void updateUser(DbSession dbSession, NewValue newValue); | |||
void updateUser(DbSession dbSession, UserNewValue newValue); | |||
void updateUserPassword(DbSession dbSession, NewValue newValue); | |||
void updateUserPassword(DbSession dbSession, SecretNewValue newValue); | |||
void updateWebhookSecret(DbSession dbSession, NewValue newValue); | |||
void updateWebhookSecret(DbSession dbSession, SecretNewValue newValue); | |||
void updateDevOpsPlatformSecret(DbSession dbSession, NewValue newValue); | |||
void updateDevOpsPlatformSecret(DbSession dbSession, SecretNewValue newValue); | |||
void deactivateUser(DbSession dbSession, NewValue newValue); | |||
void deactivateUser(DbSession dbSession, UserNewValue newValue); | |||
void addUserToGroup(DbSession dbSession, NewValue newValue); | |||
void addUserToGroup(DbSession dbSession, UserGroupNewValue newValue); | |||
void deleteUserFromGroup(DbSession dbSession, NewValue newValue); | |||
void deleteUserFromGroup(DbSession dbSession, UserGroupNewValue newValue); | |||
void addProperty(DbSession dbSession, NewValue newValue, boolean isUserProperty); | |||
void addProperty(DbSession dbSession, PropertyNewValue newValue, boolean isUserProperty); | |||
void updateProperty(DbSession dbSession, NewValue newValue, boolean isUserProperty); | |||
void updateProperty(DbSession dbSession, PropertyNewValue newValue, boolean isUserProperty); | |||
void deleteProperty(DbSession dbSession, NewValue newValue, boolean isUserProperty); | |||
void deleteProperty(DbSession dbSession, PropertyNewValue newValue, boolean isUserProperty); | |||
void addUserToken(DbSession dbSession, NewValue newValue); | |||
void addUserToken(DbSession dbSession, UserTokenNewValue newValue); | |||
void updateUserToken(DbSession dbSession, NewValue newValue); | |||
void updateUserToken(DbSession dbSession, UserTokenNewValue newValue); | |||
void deleteUserToken(DbSession dbSession, NewValue newValue); | |||
void deleteUserToken(DbSession dbSession, UserTokenNewValue newValue); | |||
void addGroupPermission(DbSession dbSession, NewValue newValue); | |||
void addGroupPermission(DbSession dbSession, GroupPermissionNewValue newValue); | |||
void deleteGroupPermission(DbSession dbSession, NewValue newValue); | |||
void deleteGroupPermission(DbSession dbSession, GroupPermissionNewValue newValue); | |||
void addUserPermission(DbSession dbSession, NewValue newValue); | |||
void addUserPermission(DbSession dbSession, UserPermissionNewValue newValue); | |||
void deleteUserPermission(DbSession dbSession, NewValue newValue); | |||
void deleteUserPermission(DbSession dbSession, UserPermissionNewValue newValue); | |||
void addPermissionTemplate(DbSession dbSession, NewValue newValue); | |||
void addPermissionTemplate(DbSession dbSession, PermissionTemplateNewValue newValue); | |||
void updatePermissionTemplate(DbSession dbSession, NewValue newValue); | |||
void updatePermissionTemplate(DbSession dbSession, PermissionTemplateNewValue newValue); | |||
void deletePermissionTemplate(DbSession dbSession, NewValue newValue); | |||
void deletePermissionTemplate(DbSession dbSession, PermissionTemplateNewValue newValue); | |||
void addUserToPermissionTemplate(DbSession dbSession, NewValue newValue); | |||
void addUserToPermissionTemplate(DbSession dbSession, PermissionTemplateNewValue newValue); | |||
void deleteUserFromPermissionTemplate(DbSession dbSession, NewValue newValue); | |||
void deleteUserFromPermissionTemplate(DbSession dbSession, PermissionTemplateNewValue newValue); | |||
void addGroupToPermissionTemplate(DbSession dbSession, NewValue newValue); | |||
void addGroupToPermissionTemplate(DbSession dbSession, PermissionTemplateNewValue newValue); | |||
void deleteGroupFromPermissionTemplate(DbSession dbSession, NewValue newValue); | |||
void deleteGroupFromPermissionTemplate(DbSession dbSession, PermissionTemplateNewValue newValue); | |||
void addCharacteristicToPermissionTemplate(DbSession dbSession, NewValue newValue); | |||
void addCharacteristicToPermissionTemplate(DbSession dbSession, PermissionTemplateNewValue newValue); | |||
void updateCharacteristicInPermissionTemplate(DbSession dbSession, NewValue newValue); | |||
void updateCharacteristicInPermissionTemplate(DbSession dbSession, PermissionTemplateNewValue newValue); | |||
void addPlugin(DbSession dbSession, NewValue newValue); | |||
void addPlugin(DbSession dbSession, PluginNewValue newValue); | |||
void updatePlugin(DbSession dbSession, NewValue newValue); | |||
void updatePlugin(DbSession dbSession, PluginNewValue newValue); | |||
void generateSecretKey(DbSession dbSession); | |||
void setLicense(DbSession dbSession, boolean isSet, NewValue newValue); | |||
void setLicense(DbSession dbSession, boolean isSet, LicenseNewValue newValue); | |||
void addWebhook(DbSession dbSession, NewValue newValue); | |||
void addWebhook(DbSession dbSession, WebhookNewValue newValue); | |||
void updateWebhook(DbSession dbSession, NewValue newValue); | |||
void updateWebhook(DbSession dbSession, WebhookNewValue newValue); | |||
void deleteWebhook(DbSession dbSession, NewValue newValue); | |||
void deleteWebhook(DbSession dbSession, WebhookNewValue newValue); | |||
void addDevOpsPlatformSetting(DbSession dbSession, NewValue newValue); | |||
void addDevOpsPlatformSetting(DbSession dbSession, DevOpsPlatformSettingNewValue newValue); | |||
void updateDevOpsPlatformSetting(DbSession dbSession, NewValue newValue); | |||
void updateDevOpsPlatformSetting(DbSession dbSession, DevOpsPlatformSettingNewValue newValue); | |||
void deleteDevOpsPlatformSetting(DbSession dbSession, NewValue newValue); | |||
void deleteDevOpsPlatformSetting(DbSession dbSession, DevOpsPlatformSettingNewValue newValue); | |||
void addPersonalAccessToken(DbSession dbSession, NewValue newValue); | |||
void addPersonalAccessToken(DbSession dbSession, PersonalAccessTokenNewValue newValue); | |||
void updatePersonalAccessToken(DbSession dbSession, NewValue newValue); | |||
void updatePersonalAccessToken(DbSession dbSession, PersonalAccessTokenNewValue newValue); | |||
void deletePersonalAccessToken(DbSession dbSession, NewValue newValue); | |||
void deletePersonalAccessToken(DbSession dbSession, PersonalAccessTokenNewValue newValue); | |||
boolean isTrackedProperty(String propertyKey); | |||
void addComponent(DbSession dbSession, NewValue newValue, String qualifier); | |||
void addComponent(DbSession dbSession, ComponentNewValue newValue); | |||
void deleteComponent(DbSession dbSession, NewValue newValue, @Nullable String qualifier); | |||
void deleteComponent(DbSession dbSession, ComponentNewValue newValue); | |||
void updateComponent(DbSession dbSession, NewValue newValue, String qualifier); | |||
void updateComponent(DbSession dbSession, ComponentNewValue newValue); | |||
void updateComponentVisibility(DbSession session, NewValue componentNewValue, @Nullable String qualifier); | |||
void updateComponentVisibility(DbSession session, ComponentNewValue componentNewValue); | |||
void componentKeyUpdate(DbSession session, NewValue componentKeyNewValue, String qualifier); | |||
void componentKeyUpdate(DbSession session, ComponentKeyNewValue componentKeyNewValue, String qualifier); | |||
void componentKeyBranchUpdate(DbSession session, NewValue componentKeyNewValue, String qualifier); | |||
void componentKeyBranchUpdate(DbSession session, ComponentKeyNewValue componentKeyNewValue, String qualifier); | |||
} |
@@ -0,0 +1,289 @@ | |||
/* | |||
* SonarQube | |||
* Copyright (C) 2009-2021 SonarSource SA | |||
* mailto:info AT sonarsource DOT com | |||
* | |||
* This program is free software; you can redistribute it and/or | |||
* modify it under the terms of the GNU Lesser General Public | |||
* License as published by the Free Software Foundation; either | |||
* version 3 of the License, or (at your option) any later version. | |||
* | |||
* This program is distributed in the hope that it will be useful, | |||
* but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |||
* Lesser General Public License for more details. | |||
* | |||
* You should have received a copy of the GNU Lesser General Public License | |||
* along with this program; if not, write to the Free Software Foundation, | |||
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. | |||
*/ | |||
package org.sonar.db.audit; | |||
import org.sonar.db.DbSession; | |||
import org.sonar.db.audit.model.ComponentKeyNewValue; | |||
import org.sonar.db.audit.model.ComponentNewValue; | |||
import org.sonar.db.audit.model.DevOpsPlatformSettingNewValue; | |||
import org.sonar.db.audit.model.GroupPermissionNewValue; | |||
import org.sonar.db.audit.model.LicenseNewValue; | |||
import org.sonar.db.audit.model.PermissionTemplateNewValue; | |||
import org.sonar.db.audit.model.PersonalAccessTokenNewValue; | |||
import org.sonar.db.audit.model.PluginNewValue; | |||
import org.sonar.db.audit.model.PropertyNewValue; | |||
import org.sonar.db.audit.model.SecretNewValue; | |||
import org.sonar.db.audit.model.UserGroupNewValue; | |||
import org.sonar.db.audit.model.UserNewValue; | |||
import org.sonar.db.audit.model.UserPermissionNewValue; | |||
import org.sonar.db.audit.model.UserTokenNewValue; | |||
import org.sonar.db.audit.model.WebhookNewValue; | |||
public class NoOpAuditPersister implements AuditPersister { | |||
@Override | |||
public void addUserGroup(DbSession dbSession, UserGroupNewValue newValue) { | |||
// no op | |||
} | |||
@Override | |||
public void updateUserGroup(DbSession dbSession, UserGroupNewValue newValue) { | |||
// no op | |||
} | |||
@Override | |||
public void deleteUserGroup(DbSession dbSession, UserGroupNewValue newValue) { | |||
// no op | |||
} | |||
@Override | |||
public void addUser(DbSession dbSession, UserNewValue newValue) { | |||
// no op | |||
} | |||
@Override | |||
public void updateUser(DbSession dbSession, UserNewValue newValue) { | |||
// no op | |||
} | |||
@Override | |||
public void updateUserPassword(DbSession dbSession, SecretNewValue newValue) { | |||
// no op | |||
} | |||
@Override | |||
public void updateWebhookSecret(DbSession dbSession, SecretNewValue newValue) { | |||
// no op | |||
} | |||
@Override | |||
public void updateDevOpsPlatformSecret(DbSession dbSession, SecretNewValue newValue) { | |||
// no op | |||
} | |||
@Override | |||
public void deactivateUser(DbSession dbSession, UserNewValue newValue) { | |||
// no op | |||
} | |||
@Override | |||
public void addUserToGroup(DbSession dbSession, UserGroupNewValue newValue) { | |||
// no op | |||
} | |||
@Override | |||
public void deleteUserFromGroup(DbSession dbSession, UserGroupNewValue newValue) { | |||
// no op | |||
} | |||
@Override | |||
public void addProperty(DbSession dbSession, PropertyNewValue newValue, boolean isUserProperty) { | |||
// no op | |||
} | |||
@Override | |||
public void updateProperty(DbSession dbSession, PropertyNewValue newValue, boolean isUserProperty) { | |||
// no op | |||
} | |||
@Override | |||
public void deleteProperty(DbSession dbSession, PropertyNewValue newValue, boolean isUserProperty) { | |||
// no op | |||
} | |||
@Override | |||
public void addUserToken(DbSession dbSession, UserTokenNewValue newValue) { | |||
// no op | |||
} | |||
@Override | |||
public void updateUserToken(DbSession dbSession, UserTokenNewValue newValue) { | |||
// no op | |||
} | |||
@Override | |||
public void deleteUserToken(DbSession dbSession, UserTokenNewValue newValue) { | |||
// no op | |||
} | |||
@Override | |||
public void addGroupPermission(DbSession dbSession, GroupPermissionNewValue newValue) { | |||
// no op | |||
} | |||
@Override | |||
public void deleteGroupPermission(DbSession dbSession, GroupPermissionNewValue newValue) { | |||
// no op | |||
} | |||
@Override | |||
public void addUserPermission(DbSession dbSession, UserPermissionNewValue newValue) { | |||
// no op | |||
} | |||
@Override | |||
public void deleteUserPermission(DbSession dbSession, UserPermissionNewValue newValue) { | |||
// no op | |||
} | |||
@Override | |||
public void addPermissionTemplate(DbSession dbSession, PermissionTemplateNewValue newValue) { | |||
// no op | |||
} | |||
@Override | |||
public void updatePermissionTemplate(DbSession dbSession, PermissionTemplateNewValue newValue) { | |||
// no op | |||
} | |||
@Override | |||
public void deletePermissionTemplate(DbSession dbSession, PermissionTemplateNewValue newValue) { | |||
// no op | |||
} | |||
@Override | |||
public void addUserToPermissionTemplate(DbSession dbSession, PermissionTemplateNewValue newValue) { | |||
// no op | |||
} | |||
@Override | |||
public void deleteUserFromPermissionTemplate(DbSession dbSession, PermissionTemplateNewValue newValue) { | |||
// no op | |||
} | |||
@Override | |||
public void addGroupToPermissionTemplate(DbSession dbSession, PermissionTemplateNewValue newValue) { | |||
// no op | |||
} | |||
@Override | |||
public void deleteGroupFromPermissionTemplate(DbSession dbSession, PermissionTemplateNewValue newValue) { | |||
// no op | |||
} | |||
@Override | |||
public void addCharacteristicToPermissionTemplate(DbSession dbSession, PermissionTemplateNewValue newValue) { | |||
// no op | |||
} | |||
@Override | |||
public void updateCharacteristicInPermissionTemplate(DbSession dbSession, PermissionTemplateNewValue newValue) { | |||
// no op | |||
} | |||
@Override | |||
public void addPlugin(DbSession dbSession, PluginNewValue newValue) { | |||
// no op | |||
} | |||
@Override | |||
public void updatePlugin(DbSession dbSession, PluginNewValue newValue) { | |||
// no op | |||
} | |||
@Override | |||
public void generateSecretKey(DbSession dbSession) { | |||
// no op | |||
} | |||
@Override | |||
public void setLicense(DbSession dbSession, boolean isSet, LicenseNewValue newValue) { | |||
// no op | |||
} | |||
@Override | |||
public void addWebhook(DbSession dbSession, WebhookNewValue newValue) { | |||
// no op | |||
} | |||
@Override | |||
public void updateWebhook(DbSession dbSession, WebhookNewValue newValue) { | |||
// no op | |||
} | |||
@Override | |||
public void deleteWebhook(DbSession dbSession, WebhookNewValue newValue) { | |||
// no op | |||
} | |||
@Override | |||
public void addDevOpsPlatformSetting(DbSession dbSession, DevOpsPlatformSettingNewValue newValue) { | |||
// no op | |||
} | |||
@Override | |||
public void updateDevOpsPlatformSetting(DbSession dbSession, DevOpsPlatformSettingNewValue newValue) { | |||
// no op | |||
} | |||
@Override | |||
public void deleteDevOpsPlatformSetting(DbSession dbSession, DevOpsPlatformSettingNewValue newValue) { | |||
// no op | |||
} | |||
@Override | |||
public void addPersonalAccessToken(DbSession dbSession, PersonalAccessTokenNewValue newValue) { | |||
// no op | |||
} | |||
@Override | |||
public void updatePersonalAccessToken(DbSession dbSession, PersonalAccessTokenNewValue newValue) { | |||
// no op | |||
} | |||
@Override | |||
public void deletePersonalAccessToken(DbSession dbSession, PersonalAccessTokenNewValue newValue) { | |||
// no op | |||
} | |||
@Override | |||
public boolean isTrackedProperty(String propertyKey) { | |||
return false; | |||
} | |||
@Override | |||
public void addComponent(DbSession dbSession, ComponentNewValue newValue) { | |||
// no op | |||
} | |||
@Override | |||
public void deleteComponent(DbSession dbSession, ComponentNewValue newValue) { | |||
// no op | |||
} | |||
@Override | |||
public void updateComponent(DbSession dbSession, ComponentNewValue newValue) { | |||
// no op | |||
} | |||
@Override | |||
public void updateComponentVisibility(DbSession session, ComponentNewValue componentNewValue) { | |||
// no op | |||
} | |||
@Override | |||
public void componentKeyUpdate(DbSession session, ComponentKeyNewValue componentKeyNewValue, String qualifier) { | |||
// no op | |||
} | |||
@Override | |||
public void componentKeyBranchUpdate(DbSession session, ComponentKeyNewValue componentKeyNewValue, String qualifier) { | |||
// no op | |||
} | |||
} |
@@ -19,13 +19,16 @@ | |||
*/ | |||
package org.sonar.db.audit.model; | |||
public class ComponentKeyNewValue extends NewValue{ | |||
import static com.google.common.base.Preconditions.checkNotNull; | |||
public class ComponentKeyNewValue extends NewValue { | |||
private final String componentUuid; | |||
private final String oldKey; | |||
private final String newKey; | |||
public ComponentKeyNewValue(String componentUuid, String oldKey, String newKey) { | |||
checkNotNull(componentUuid, oldKey, newKey); | |||
this.componentUuid = componentUuid; | |||
this.oldKey = oldKey; | |||
this.newKey = newKey; |
@@ -22,51 +22,54 @@ package org.sonar.db.audit.model; | |||
import javax.annotation.CheckForNull; | |||
import javax.annotation.Nullable; | |||
import org.apache.commons.lang.ObjectUtils; | |||
import org.sonar.db.component.ComponentDto; | |||
import org.sonar.db.project.ProjectDto; | |||
public class ComponentNewValue extends NewValue { | |||
import static java.util.Objects.requireNonNull; | |||
private String componentUuid; | |||
private String componentName; | |||
@Nullable | |||
private String description; | |||
private String rootComponentUuid; | |||
private String path; | |||
private String componentKey; | |||
private Boolean isPrivate; | |||
public class ComponentNewValue extends NewValue { | |||
private final String componentUuid; | |||
private final String componentKey; | |||
private final String componentName; | |||
private final String description; | |||
private final Boolean isPrivate; | |||
private final String qualifier; | |||
private Boolean isEnabled; | |||
private String qualifier; | |||
private String path; | |||
public ComponentNewValue(String componentUuid, String name, String componentKey, @Nullable String qualifier) { | |||
this.componentUuid = componentUuid; | |||
this.componentName = name; | |||
this.componentKey = componentKey; | |||
this.qualifier = getQualifier(qualifier); | |||
public ComponentNewValue(ProjectDto project) { | |||
this(project.getUuid(), project.getName(), project.getKey(), project.isPrivate(), project.getDescription(), project.getQualifier()); | |||
} | |||
public ComponentNewValue(String componentUuid, String name, String componentKey, boolean isPrivate, String qualifier) { | |||
this.componentUuid = componentUuid; | |||
this.componentName = name; | |||
this.componentKey = componentKey; | |||
this.isPrivate = isPrivate; | |||
this.qualifier = getQualifier(qualifier); | |||
public ComponentNewValue(ComponentDto component) { | |||
this(component.uuid(), component.name(), component.getKey(), component.isPrivate(), component.description(), component.qualifier()); | |||
} | |||
public ComponentNewValue(String uuid, String name, String componentKey, boolean enabled, String path, @Nullable String qualifier) { | |||
this.componentUuid = uuid; | |||
this.componentName = name; | |||
public ComponentNewValue(String componentUuid, String componentName, String componentKey, String qualifier) { | |||
this(componentUuid, componentName, componentKey, null, null, qualifier); | |||
} | |||
public ComponentNewValue(String componentUuid, String componentName, String componentKey, boolean isPrivate, String qualifier) { | |||
this(componentUuid, isPrivate, componentName, componentKey, null, qualifier); | |||
} | |||
public ComponentNewValue(String uuid, String name, String key, boolean enabled, String path, String qualifier) { | |||
this(uuid, name, key, null, null, qualifier); | |||
this.isEnabled = enabled; | |||
this.path = path; | |||
this.componentKey = componentKey; | |||
this.qualifier = getQualifier(qualifier); | |||
} | |||
public ComponentNewValue(String uuid, boolean isPrivate, String name, String componentKey, @Nullable String description, @Nullable String qualifier) { | |||
this.componentUuid = uuid; | |||
this.isPrivate = isPrivate; | |||
public ComponentNewValue(String uuid, @Nullable Boolean isPrivate, String name, String key, @Nullable String description, String qualifier) { | |||
this(uuid, name, key, isPrivate, description, qualifier); | |||
} | |||
private ComponentNewValue(String uuid, String name, String key, @Nullable Boolean isPrivate, @Nullable String description, String qualifier) { | |||
this.componentUuid = requireNonNull(uuid); | |||
this.componentName = name; | |||
this.componentKey = componentKey; | |||
this.componentKey = key; | |||
this.isPrivate = isPrivate; | |||
this.description = description; | |||
this.qualifier = getQualifier(qualifier); | |||
this.qualifier = qualifier; | |||
} | |||
public String getComponentUuid() { | |||
@@ -86,6 +89,7 @@ public class ComponentNewValue extends NewValue { | |||
return componentKey; | |||
} | |||
@CheckForNull | |||
public boolean isPrivate() { | |||
return isPrivate; | |||
} | |||
@@ -98,10 +102,9 @@ public class ComponentNewValue extends NewValue { | |||
public String toString() { | |||
StringBuilder sb = new StringBuilder("{"); | |||
addField(sb, "\"componentUuid\": ", this.componentUuid, true); | |||
addField(sb, "\"rootComponentUuid\": ", this.rootComponentUuid, true); | |||
addField(sb, "\"componentKey\": ", this.componentKey, true); | |||
addField(sb, "\"componentName\": ", this.componentName, true); | |||
addField(sb, "\"qualifier\": ", this.qualifier, true); | |||
addField(sb, "\"qualifier\": ", getQualifier(qualifier), true); | |||
addField(sb, "\"description\": ", this.description, true); | |||
addField(sb, "\"path\": ", this.path, true); | |||
addField(sb, "\"isPrivate\": ", ObjectUtils.toString(this.isPrivate), false); |
@@ -31,23 +31,18 @@ public class GroupPermissionNewValue extends PermissionNewValue { | |||
@Nullable | |||
private String groupName; | |||
public GroupPermissionNewValue(String uuid, String rootComponentUuid, String componentKey, String componentName, | |||
String role, String groupUuid, String groupName, String qualifier, | |||
@Nullable PermissionTemplateDto permissionTemplateDto) { | |||
super(uuid, rootComponentUuid, componentKey, componentName, role, qualifier, permissionTemplateDto); | |||
public GroupPermissionNewValue(String uuid, String componentUuid, String componentKey, String componentName, String role, String groupUuid, String groupName, | |||
String qualifier, @Nullable PermissionTemplateDto permissionTemplate) { | |||
super(uuid, componentUuid, componentKey, componentName, role, qualifier, permissionTemplate); | |||
this.groupUuid = groupUuid; | |||
this.groupName = groupName; | |||
} | |||
public GroupPermissionNewValue(String rootComponentUuid, String componentKey, String componentName, String role, | |||
String groupUuid, String groupName, String qualifier) { | |||
this(null, rootComponentUuid, componentKey, componentName, role, groupUuid, groupName, qualifier, null); | |||
public GroupPermissionNewValue(String componentUuid, String componentKey, String componentName, String role, String groupUuid, String groupName, String qualifier) { | |||
this(null, componentUuid, componentKey, componentName, role, groupUuid, groupName, qualifier, null); | |||
} | |||
public GroupPermissionNewValue(GroupPermissionDto dto, @Nullable String componentKey, @Nullable String qualifier, | |||
@Nullable PermissionTemplateDto permissionTemplateDto) { | |||
this(dto.getUuid(), dto.getComponentUuid(), componentKey, dto.getComponentName(), dto.getRole(), dto.getGroupUuid(), | |||
dto.getGroupName(), qualifier, permissionTemplateDto); | |||
public GroupPermissionNewValue(GroupPermissionDto dto, String componentKey, String qualifier, PermissionTemplateDto permissionTemplate) { | |||
this(dto.getUuid(), dto.getComponentUuid(), componentKey, dto.getComponentName(), dto.getRole(), dto.getGroupUuid(), dto.getGroupName(), qualifier, permissionTemplate); | |||
} | |||
@Nullable | |||
@@ -72,7 +67,7 @@ public class GroupPermissionNewValue extends PermissionNewValue { | |||
addField(sb, "\"componentName\": ", this.componentName, true); | |||
addField(sb, "\"permissionTemplateUuid\": ", this.permissionTemplateId, true); | |||
addField(sb, "\"permissionTemplateName\": ", this.permissionTemplateName, true); | |||
addField(sb, "\"qualifier\": ", this.qualifier, true); | |||
addField(sb, "\"qualifier\": ", getQualifier(this.qualifier), true); | |||
endString(sb); | |||
return sb.toString(); | |||
} |
@@ -24,7 +24,7 @@ import javax.annotation.Nullable; | |||
public class LicenseNewValue extends NewValue { | |||
@Nullable | |||
private String edition; | |||
private final String edition; | |||
public LicenseNewValue(@Nullable String edition) { | |||
this.edition = edition; |
@@ -19,6 +19,7 @@ | |||
*/ | |||
package org.sonar.db.audit.model; | |||
import javax.annotation.CheckForNull; | |||
import javax.annotation.Nullable; | |||
import static com.google.common.base.Strings.isNullOrEmpty; | |||
@@ -28,7 +29,7 @@ import static org.sonar.api.resources.Qualifiers.VIEW; | |||
public abstract class NewValue { | |||
protected void addField(StringBuilder sb, String field, String value, boolean isString) { | |||
protected void addField(StringBuilder sb, String field, @Nullable String value, boolean isString) { | |||
if (!isNullOrEmpty(value)) { | |||
sb.append(field); | |||
addQuote(sb, isString); | |||
@@ -52,6 +53,7 @@ public abstract class NewValue { | |||
} | |||
} | |||
@CheckForNull | |||
protected static String getQualifier(@Nullable String qualifier) { | |||
if (qualifier == null) { | |||
return null; |
@@ -54,7 +54,7 @@ public abstract class PermissionNewValue extends NewValue { | |||
this.componentUuid = componentUuid; | |||
this.componentKey = componentKey; | |||
this.componentName = componentName; | |||
this.qualifier = getQualifier(qualifier); | |||
this.qualifier = qualifier; | |||
this.permission = permission; | |||
this.permissionTemplateId = permissionTemplateDto == null ? null : permissionTemplateDto.getUuid(); | |||
this.permissionTemplateName = permissionTemplateDto == null ? null : permissionTemplateDto.getName(); |
@@ -22,10 +22,10 @@ package org.sonar.db.audit.model; | |||
import org.sonar.db.plugin.PluginDto; | |||
public class PluginNewValue extends NewValue { | |||
private String pluginUuid; | |||
private String kee; | |||
private String basePluginKey; | |||
private String type; | |||
private final String pluginUuid; | |||
private final String kee; | |||
private final String basePluginKey; | |||
private final String type; | |||
public PluginNewValue(PluginDto pluginDto) { | |||
this.pluginUuid = pluginDto.getUuid(); |
@@ -25,7 +25,6 @@ import org.sonar.db.property.PropertyDto; | |||
import org.sonar.db.user.UserPropertyDto; | |||
public class PropertyNewValue extends NewValue { | |||
@Nullable | |||
private String propertyKey; | |||
@Nullable | |||
@@ -57,15 +56,14 @@ public class PropertyNewValue extends NewValue { | |||
setValue(propertyKey, userPropertyDto.getValue()); | |||
} | |||
public PropertyNewValue(PropertyDto propertyDto, @Nullable String userLogin, @Nullable String componentKey, | |||
@Nullable String componentName, @Nullable String qualifier) { | |||
public PropertyNewValue(PropertyDto propertyDto, @Nullable String userLogin, @Nullable String componentKey, @Nullable String componentName, @Nullable String qualifier) { | |||
this.propertyKey = propertyDto.getKey(); | |||
this.userUuid = propertyDto.getUserUuid(); | |||
this.userLogin = userLogin; | |||
this.componentUuid = propertyDto.getComponentUuid(); | |||
this.componentKey = componentKey; | |||
this.componentName = componentName; | |||
this.qualifier = getQualifier(qualifier); | |||
this.qualifier = qualifier; | |||
setValue(propertyKey, propertyDto.getValue()); | |||
} | |||
@@ -86,17 +84,16 @@ public class PropertyNewValue extends NewValue { | |||
setValue(propertyKey, propertyValue); | |||
} | |||
public PropertyNewValue(@Nullable String propertyKey, @Nullable String projectUuid, @Nullable String componentKey, | |||
public PropertyNewValue(String propertyKey, @Nullable String projectUuid, @Nullable String componentKey, | |||
@Nullable String componentName, @Nullable String qualifier, @Nullable String userUuid) { | |||
this.propertyKey = propertyKey; | |||
this.componentUuid = projectUuid; | |||
this.componentKey = componentKey; | |||
this.componentName = componentName; | |||
this.userUuid = userUuid; | |||
this.qualifier = getQualifier(qualifier); | |||
this.qualifier = qualifier; | |||
} | |||
@CheckForNull | |||
public String getPropertyKey() { | |||
return this.propertyKey; | |||
} | |||
@@ -146,7 +143,7 @@ public class PropertyNewValue extends NewValue { | |||
addField(sb, "\"componentUuid\": ", this.componentUuid, true); | |||
addField(sb, "\"componentKey\": ", this.componentKey, true); | |||
addField(sb, "\"componentName\": ", this.componentName, true); | |||
addField(sb, "\"qualifier\": ", this.qualifier, true); | |||
addField(sb, "\"qualifier\": ", getQualifier(this.qualifier), true); | |||
endString(sb); | |||
return sb.toString(); | |||
} |
@@ -25,51 +25,42 @@ import org.sonar.db.user.GroupDto; | |||
import org.sonar.db.user.UserDto; | |||
import org.sonar.db.user.UserGroupDto; | |||
public class UserGroupNewValue extends NewValue { | |||
@Nullable | |||
private String groupUuid; | |||
@Nullable | |||
private String name; | |||
import static com.google.common.base.Preconditions.checkState; | |||
@Nullable | |||
private String description; | |||
@Nullable | |||
private String userUuid; | |||
@Nullable | |||
private String userLogin; | |||
public class UserGroupNewValue extends NewValue { | |||
private final String groupUuid; | |||
private final String name; | |||
private final String userUuid; | |||
private final String userLogin; | |||
private final String description; | |||
public UserGroupNewValue(String groupUuid, String name) { | |||
this.groupUuid = groupUuid; | |||
this.name = name; | |||
this(groupUuid, name, null, null, null); | |||
} | |||
public UserGroupNewValue(GroupDto groupDto) { | |||
this.groupUuid = groupDto.getUuid(); | |||
this.name = groupDto.getName(); | |||
this.description = groupDto.getDescription(); | |||
this(groupDto.getUuid(), groupDto.getName(), null, null, groupDto.getDescription()); | |||
} | |||
public UserGroupNewValue(GroupDto groupDto, UserDto userDto) { | |||
this.groupUuid = groupDto.getUuid(); | |||
this.name = groupDto.getName(); | |||
this.userUuid = userDto.getUuid(); | |||
this.userLogin = userDto.getLogin(); | |||
this(groupDto.getUuid(), groupDto.getName(), userDto.getUuid(), userDto.getLogin(), null); | |||
} | |||
public UserGroupNewValue(UserDto userDto) { | |||
this.userUuid = userDto.getUuid(); | |||
this.userLogin = userDto.getLogin(); | |||
this(null, null, userDto.getUuid(), userDto.getLogin(), null); | |||
} | |||
public UserGroupNewValue(UserGroupDto userGroupDto, String groupName, String userLogin) { | |||
this.groupUuid = userGroupDto.getGroupUuid(); | |||
this.userUuid = userGroupDto.getUserUuid(); | |||
this.name = groupName; | |||
this(userGroupDto.getGroupUuid(), groupName, userGroupDto.getUserUuid(), userLogin, null); | |||
} | |||
private UserGroupNewValue(@Nullable String groupUuid, @Nullable String name, @Nullable String userUuid, @Nullable String userLogin, @Nullable String description) { | |||
checkState((groupUuid != null && name != null) || (userUuid != null && userLogin != null)); | |||
this.groupUuid = groupUuid; | |||
this.name = name; | |||
this.userUuid = userUuid; | |||
this.userLogin = userLogin; | |||
this.description = description; | |||
} | |||
@CheckForNull |
@@ -24,6 +24,8 @@ import javax.annotation.Nullable; | |||
import org.apache.commons.lang.ObjectUtils; | |||
import org.sonar.db.user.UserDto; | |||
import static java.util.Objects.requireNonNull; | |||
public class UserNewValue extends NewValue { | |||
private String userUuid; | |||
private String userLogin; | |||
@@ -62,8 +64,8 @@ public class UserNewValue extends NewValue { | |||
private Long lastConnectionDate; | |||
public UserNewValue(String userUuid, String userLogin) { | |||
this.userUuid = userUuid; | |||
this.userLogin = userLogin; | |||
this.userUuid = requireNonNull(userUuid); | |||
this.userLogin = requireNonNull(userLogin); | |||
} | |||
public UserNewValue(UserDto userDto) { |
@@ -34,8 +34,7 @@ public class UserPermissionNewValue extends PermissionNewValue { | |||
public UserPermissionNewValue(UserPermissionDto permissionDto, @Nullable String componentKey, @Nullable String componentName, | |||
@Nullable UserId userId, String qualifier, @Nullable PermissionTemplateDto templateDto) { | |||
super(permissionDto.getUuid(), permissionDto.getComponentUuid(), componentKey, componentName, permissionDto.getPermission(), | |||
qualifier, templateDto); | |||
super(permissionDto.getUuid(), permissionDto.getComponentUuid(), componentKey, componentName, permissionDto.getPermission(), qualifier, templateDto); | |||
this.userUuid = userId != null ? userId.getUuid() : null; | |||
this.userLogin = userId != null ? userId.getLogin() : null; | |||
} | |||
@@ -73,7 +72,7 @@ public class UserPermissionNewValue extends PermissionNewValue { | |||
addField(sb, "\"permissionTemplateName\": ", this.permissionTemplateName, true); | |||
addField(sb, "\"userUuid\": ", this.userUuid, true); | |||
addField(sb, "\"userLogin\": ", this.userLogin, true); | |||
addField(sb, "\"qualifier\": ", this.qualifier, true); | |||
addField(sb, "\"qualifier\": ", getQualifier(this.qualifier), true); | |||
endString(sb); | |||
return sb.toString(); | |||
} |
@@ -53,11 +53,7 @@ import static org.sonar.db.component.ComponentDto.generateBranchKey; | |||
import static org.sonar.db.component.ComponentDto.generatePullRequestKey; | |||
public class ComponentDao implements Dao { | |||
private AuditPersister auditPersister; | |||
public ComponentDao() { | |||
//intentionally empty | |||
} | |||
private final AuditPersister auditPersister; | |||
public ComponentDao(AuditPersister auditPersister) { | |||
this.auditPersister = auditPersister; | |||
@@ -338,10 +334,8 @@ public class ComponentDao implements Dao { | |||
} | |||
public void insert(DbSession session, ComponentDto item) { | |||
if (auditPersister != null) { | |||
auditPersister.addComponent(session, new ComponentNewValue(item.uuid(), item.name(), item.getKey(), item.qualifier()), item.qualifier()); | |||
} | |||
mapper(session).insert(item); | |||
auditPersister.addComponent(session, new ComponentNewValue(item)); | |||
} | |||
public void insert(DbSession session, Collection<ComponentDto> items) { | |||
@@ -357,10 +351,8 @@ public class ComponentDao implements Dao { | |||
} | |||
public void update(DbSession session, ComponentUpdateDto component, String qualifier) { | |||
if (auditPersister != null) { | |||
auditPersister.updateComponent(session, new ComponentNewValue(component.getUuid(), component.getBName(), | |||
component.getBKey(), component.isBEnabled(), component.getBPath(), qualifier), qualifier); | |||
} | |||
auditPersister.updateComponent(session, new ComponentNewValue(component.getUuid(), component.getBName(), | |||
component.getBKey(), component.isBEnabled(), component.getBPath(), qualifier)); | |||
mapper(session).update(component); | |||
} | |||
@@ -376,12 +368,14 @@ public class ComponentDao implements Dao { | |||
mapper(session).resetBChangedForRootComponentUuid(projectUuid); | |||
} | |||
public void setPrivateForRootComponentUuidWithoutAudit(DbSession session, String projectUuid, boolean isPrivate) { | |||
mapper(session).setPrivateForRootComponentUuid(projectUuid, isPrivate); | |||
} | |||
public void setPrivateForRootComponentUuid(DbSession session, String projectUuid, boolean isPrivate, | |||
String key, @Nullable String qualifier, String componentName, boolean track) { | |||
if (track && auditPersister != null) { | |||
ComponentNewValue componentNewValue = new ComponentNewValue(projectUuid, componentName, key, isPrivate, qualifier); | |||
auditPersister.updateComponentVisibility(session, componentNewValue, qualifier); | |||
} | |||
@Nullable String qualifier, String componentKey, String componentName) { | |||
ComponentNewValue componentNewValue = new ComponentNewValue(projectUuid, componentName, componentKey, isPrivate, qualifier); | |||
auditPersister.updateComponentVisibility(session, componentNewValue); | |||
mapper(session).setPrivateForRootComponentUuid(projectUuid, isPrivate); | |||
} | |||
@@ -42,11 +42,7 @@ import static org.sonar.db.component.ComponentDto.generateBranchKey; | |||
* @since 3.2 | |||
*/ | |||
public class ComponentKeyUpdaterDao implements Dao { | |||
private AuditPersister auditPersister; | |||
public ComponentKeyUpdaterDao() { | |||
} | |||
private final AuditPersister auditPersister; | |||
public ComponentKeyUpdaterDao(AuditPersister auditPersister) { | |||
this.auditPersister = auditPersister; | |||
@@ -86,9 +82,7 @@ public class ComponentKeyUpdaterDao implements Dao { | |||
appBranch.setKey(newAppBranchKey); | |||
mapper.updateComponent(appBranch); | |||
if(auditPersister != null) { | |||
auditPersister.componentKeyBranchUpdate(dbSession, new ComponentKeyNewValue(appBranchUuid, appBranchOldKey, newAppBranchKey), Qualifiers.APP); | |||
} | |||
auditPersister.componentKeyBranchUpdate(dbSession, new ComponentKeyNewValue(appBranchUuid, appBranchOldKey, newAppBranchKey), Qualifiers.APP); | |||
String oldAppBranchFragment = appBranchOldKey.replace(BRANCH_KEY_SEPARATOR, ""); | |||
String newAppBranchFragment = appKey + newBranchName; | |||
@@ -117,10 +111,7 @@ public class ComponentKeyUpdaterDao implements Dao { | |||
} | |||
mapper.updateComponent(resource); | |||
if (resource.getScope().equals(Scopes.PROJECT) && (resource.getQualifier().equals(Qualifiers.PROJECT) || resource.getQualifier().equals(Qualifiers.APP))) { | |||
if(auditPersister != null) { | |||
auditPersister.componentKeyUpdate(dbSession, | |||
new ComponentKeyNewValue(resource.getUuid(), oldResourceKey, newResourceKey), resource.getQualifier()); | |||
} | |||
auditPersister.componentKeyUpdate(dbSession, new ComponentKeyNewValue(resource.getUuid(), oldResourceKey, newResourceKey), resource.getQualifier()); | |||
mapper.updateProject(oldResourceKey, newResourceKey); | |||
} | |||
@@ -41,10 +41,7 @@ public class GroupPermissionDao implements Dao { | |||
private static final String ANYONE_GROUP_PARAMETER = "anyoneGroup"; | |||
private AuditPersister auditPersister; | |||
public GroupPermissionDao() { | |||
} | |||
private final AuditPersister auditPersister; | |||
public GroupPermissionDao(AuditPersister auditPersister) { | |||
this.auditPersister = auditPersister; | |||
@@ -124,15 +121,12 @@ public class GroupPermissionDao implements Dao { | |||
return mapper(session).selectGroupUuidsWithPermissionOnProjectBut(projectUuid, permission); | |||
} | |||
public void insert(DbSession dbSession, GroupPermissionDto groupPermissionDto, @Nullable ComponentDto componentDto, | |||
@Nullable PermissionTemplateDto permissionTemplateDto) { | |||
public void insert(DbSession dbSession, GroupPermissionDto groupPermissionDto, @Nullable ComponentDto componentDto, @Nullable PermissionTemplateDto permissionTemplateDto) { | |||
mapper(dbSession).insert(groupPermissionDto); | |||
if (auditPersister != null) { | |||
String componentKey = (componentDto != null) ? componentDto.getKey() : null; | |||
String qualifier = (componentDto != null) ? componentDto.qualifier() : null; | |||
auditPersister.addGroupPermission(dbSession, new GroupPermissionNewValue(groupPermissionDto, componentKey, qualifier, permissionTemplateDto)); | |||
} | |||
String componentKey = (componentDto != null) ? componentDto.getKey() : null; | |||
String qualifier = (componentDto != null) ? componentDto.qualifier() : null; | |||
auditPersister.addGroupPermission(dbSession, new GroupPermissionNewValue(groupPermissionDto, componentKey, qualifier, permissionTemplateDto)); | |||
} | |||
/** | |||
@@ -141,7 +135,7 @@ public class GroupPermissionDao implements Dao { | |||
public void deleteByRootComponentUuid(DbSession dbSession, ComponentDto component) { | |||
int deletedRecords = mapper(dbSession).deleteByRootComponentUuid(component.uuid()); | |||
if (deletedRecords > 0 && auditPersister != null) { | |||
if (deletedRecords > 0) { | |||
auditPersister.deleteGroupPermission(dbSession, new GroupPermissionNewValue(component.uuid(), | |||
component.getKey(), component.name(), null, null, null, component.qualifier())); | |||
} | |||
@@ -154,7 +148,7 @@ public class GroupPermissionDao implements Dao { | |||
public int deleteByRootComponentUuidAndGroupUuid(DbSession dbSession, @Nullable String groupUuid, ComponentDto component) { | |||
int deletedRecords = mapper(dbSession).deleteByRootComponentUuidAndGroupUuid(component.uuid(), groupUuid); | |||
if (deletedRecords > 0 && auditPersister != null) { | |||
if (deletedRecords > 0) { | |||
auditPersister.deleteGroupPermission(dbSession, new GroupPermissionNewValue(component.uuid(), | |||
component.getKey(), component.name(), null, groupUuid, "", component.qualifier())); | |||
} | |||
@@ -164,7 +158,7 @@ public class GroupPermissionDao implements Dao { | |||
public int deleteByRootComponentUuidForAnyOne(DbSession dbSession, ComponentDto component) { | |||
int deletedRecords = mapper(dbSession).deleteByRootComponentUuidAndGroupUuid(component.uuid(), null); | |||
if (deletedRecords > 0 && auditPersister != null) { | |||
if (deletedRecords > 0) { | |||
auditPersister.deleteGroupPermission(dbSession, new GroupPermissionNewValue(component.uuid(), | |||
component.getKey(), component.name(), null, null, null, component.qualifier())); | |||
} | |||
@@ -178,7 +172,7 @@ public class GroupPermissionDao implements Dao { | |||
public int deleteByRootComponentUuidAndPermission(DbSession dbSession, String permission, ComponentDto component) { | |||
int deletedRecords = mapper(dbSession).deleteByRootComponentUuidAndPermission(component.uuid(), permission); | |||
if (deletedRecords > 0 && auditPersister != null) { | |||
if (deletedRecords > 0) { | |||
auditPersister.deleteGroupPermission(dbSession, new GroupPermissionNewValue(component.uuid(), | |||
component.getKey(), component.name(), permission, null, null, component.qualifier())); | |||
} | |||
@@ -205,7 +199,7 @@ public class GroupPermissionDao implements Dao { | |||
int deletedRecords = mapper(dbSession).delete(permission, groupUuid, rootComponentUuid); | |||
if (deletedRecords > 0 && auditPersister != null) { | |||
if (deletedRecords > 0) { | |||
String qualifier = (componentDto != null) ? componentDto.qualifier() : null; | |||
String componentKey = (componentDto != null) ? componentDto.getKey() : null; | |||
String componentName = (componentDto != null) ? componentDto.name() : null; |
@@ -39,10 +39,7 @@ import static java.util.Collections.emptyList; | |||
import static org.sonar.db.DatabaseUtils.executeLargeInputs; | |||
public class UserPermissionDao implements Dao { | |||
private AuditPersister auditPersister; | |||
public UserPermissionDao() { | |||
} | |||
private final AuditPersister auditPersister; | |||
public UserPermissionDao(AuditPersister auditPersister) { | |||
this.auditPersister = auditPersister; | |||
@@ -120,13 +117,11 @@ public class UserPermissionDao implements Dao { | |||
@Nullable UserId userId, @Nullable PermissionTemplateDto templateDto) { | |||
mapper(dbSession).insert(dto); | |||
if (auditPersister != null) { | |||
String componentName = (componentDto != null) ? componentDto.name() : null; | |||
String componentKey = (componentDto != null) ? componentDto.getKey() : null; | |||
String qualifier = (componentDto != null) ? componentDto.qualifier() : null; | |||
auditPersister.addUserPermission(dbSession, new UserPermissionNewValue(dto, componentKey, componentName, userId, qualifier, | |||
templateDto)); | |||
} | |||
String componentName = (componentDto != null) ? componentDto.name() : null; | |||
String componentKey = (componentDto != null) ? componentDto.getKey() : null; | |||
String qualifier = (componentDto != null) ? componentDto.qualifier() : null; | |||
auditPersister.addUserPermission(dbSession, new UserPermissionNewValue(dto, componentKey, componentName, userId, qualifier, | |||
templateDto)); | |||
} | |||
/** | |||
@@ -135,7 +130,7 @@ public class UserPermissionDao implements Dao { | |||
public void deleteGlobalPermission(DbSession dbSession, UserId user, String permission) { | |||
int deletedRows = mapper(dbSession).deleteGlobalPermission(user.getUuid(), permission); | |||
if (deletedRows > 0 && auditPersister != null) { | |||
if (deletedRows > 0) { | |||
auditPersister.deleteUserPermission(dbSession, new UserPermissionNewValue(permission, null, null, null, user, null)); | |||
} | |||
} | |||
@@ -146,9 +141,8 @@ public class UserPermissionDao implements Dao { | |||
public void deleteProjectPermission(DbSession dbSession, UserId user, String permission, ComponentDto component) { | |||
int deletedRows = mapper(dbSession).deleteProjectPermission(user.getUuid(), permission, component.uuid()); | |||
if (deletedRows > 0 && auditPersister != null) { | |||
auditPersister.deleteUserPermission(dbSession, new UserPermissionNewValue(permission, component.uuid(), component.getKey(), | |||
component.name(), user, component.qualifier())); | |||
if (deletedRows > 0) { | |||
auditPersister.deleteUserPermission(dbSession, new UserPermissionNewValue(permission, component.uuid(), component.getKey(), component.name(), user, component.qualifier())); | |||
} | |||
} | |||
@@ -158,7 +152,7 @@ public class UserPermissionDao implements Dao { | |||
public void deleteProjectPermissions(DbSession dbSession, ComponentDto component) { | |||
int deletedRows = mapper(dbSession).deleteProjectPermissions(component.uuid()); | |||
if (deletedRows > 0 && auditPersister != null) { | |||
if (deletedRows > 0) { | |||
auditPersister.deleteUserPermission(dbSession, new UserPermissionNewValue(null, component.uuid(), component.getKey(), | |||
component.name(), null, component.qualifier())); | |||
} | |||
@@ -170,9 +164,8 @@ public class UserPermissionDao implements Dao { | |||
public int deleteProjectPermissionOfAnyUser(DbSession dbSession, String permission, ComponentDto project) { | |||
int deletedRows = mapper(dbSession).deleteProjectPermissionOfAnyUser(project.uuid(), permission); | |||
if (deletedRows > 0 && auditPersister != null) { | |||
auditPersister.deleteUserPermission(dbSession, new UserPermissionNewValue(permission, project.uuid(), project.getKey(), | |||
project.name(), null, project.qualifier())); | |||
if (deletedRows > 0) { | |||
auditPersister.deleteUserPermission(dbSession, new UserPermissionNewValue(permission, project.uuid(), project.getKey(), project.name(), null, project.qualifier())); | |||
} | |||
return deletedRows; | |||
@@ -181,7 +174,7 @@ public class UserPermissionDao implements Dao { | |||
public void deleteByUserUuid(DbSession dbSession, UserId userId) { | |||
int deletedRows = mapper(dbSession).deleteByUserUuid(userId.getUuid()); | |||
if (deletedRows > 0 && auditPersister != null) { | |||
if (deletedRows > 0) { | |||
auditPersister.deleteUserPermission(dbSession, new UserPermissionNewValue(userId, null)); | |||
} | |||
} |
@@ -31,10 +31,7 @@ import static java.util.Objects.requireNonNull; | |||
import static org.sonar.db.DatabaseUtils.executeLargeInputs; | |||
public class PermissionTemplateCharacteristicDao implements Dao { | |||
private AuditPersister auditPersister; | |||
public PermissionTemplateCharacteristicDao() { | |||
} | |||
private final AuditPersister auditPersister; | |||
public PermissionTemplateCharacteristicDao(AuditPersister auditPersister) { | |||
this.auditPersister = auditPersister; | |||
@@ -53,10 +50,8 @@ public class PermissionTemplateCharacteristicDao implements Dao { | |||
checkArgument(dto.getCreatedAt() != 0L && dto.getUpdatedAt() != 0L); | |||
mapper(dbSession).insert(dto); | |||
if (auditPersister != null) { | |||
auditPersister.addCharacteristicToPermissionTemplate(dbSession, new PermissionTemplateNewValue(dto.getTemplateUuid(), | |||
dto.getPermission(), templateName, dto.getWithProjectCreator())); | |||
} | |||
auditPersister.addCharacteristicToPermissionTemplate(dbSession, new PermissionTemplateNewValue(dto.getTemplateUuid(), | |||
dto.getPermission(), templateName, dto.getWithProjectCreator())); | |||
return dto; | |||
} | |||
@@ -66,10 +61,8 @@ public class PermissionTemplateCharacteristicDao implements Dao { | |||
requireNonNull(templatePermissionDto.getUuid()); | |||
mapper(dbSession).update(templatePermissionDto); | |||
if (auditPersister != null) { | |||
auditPersister.updateCharacteristicInPermissionTemplate(dbSession, new PermissionTemplateNewValue(templatePermissionDto.getTemplateUuid(), | |||
templatePermissionDto.getPermission(), templateName, templatePermissionDto.getWithProjectCreator())); | |||
} | |||
auditPersister.updateCharacteristicInPermissionTemplate(dbSession, new PermissionTemplateNewValue(templatePermissionDto.getTemplateUuid(), | |||
templatePermissionDto.getPermission(), templateName, templatePermissionDto.getWithProjectCreator())); | |||
return templatePermissionDto; | |||
} |
@@ -49,16 +49,11 @@ public class PermissionTemplateDao implements Dao { | |||
private final System2 system; | |||
private final UuidFactory uuidFactory; | |||
private final AuditPersister auditPersister; | |||
private AuditPersister auditPersister; | |||
public PermissionTemplateDao(UuidFactory uuidFactory, System2 system) { | |||
public PermissionTemplateDao(UuidFactory uuidFactory, System2 system, AuditPersister auditPersister) { | |||
this.uuidFactory = uuidFactory; | |||
this.system = system; | |||
} | |||
public PermissionTemplateDao(UuidFactory uuidFactory, System2 system, AuditPersister auditPersister) { | |||
this(uuidFactory, system); | |||
this.auditPersister = auditPersister; | |||
} | |||
@@ -124,10 +119,7 @@ public class PermissionTemplateDao implements Dao { | |||
dto.setUuid(uuidFactory.create()); | |||
} | |||
mapper(session).insert(dto); | |||
if (auditPersister != null) { | |||
auditPersister.addPermissionTemplate(session, new PermissionTemplateNewValue(dto.getUuid(), dto.getName())); | |||
} | |||
auditPersister.addPermissionTemplate(session, new PermissionTemplateNewValue(dto.getUuid(), dto.getName())); | |||
return dto; | |||
} | |||
@@ -172,16 +164,14 @@ public class PermissionTemplateDao implements Dao { | |||
session.getMapper(PermissionTemplateCharacteristicMapper.class).deleteByTemplateUuid(templateUuid); | |||
int deletedRows = mapper.deleteByUuid(templateUuid); | |||
if (deletedRows > 0 && auditPersister != null) { | |||
if (deletedRows > 0) { | |||
auditPersister.deletePermissionTemplate(session, new PermissionTemplateNewValue(templateUuid, templateName)); | |||
} | |||
} | |||
public PermissionTemplateDto update(DbSession session, PermissionTemplateDto permissionTemplate) { | |||
mapper(session).update(permissionTemplate); | |||
if (auditPersister != null) { | |||
auditPersister.updatePermissionTemplate(session, new PermissionTemplateNewValue(permissionTemplate)); | |||
} | |||
auditPersister.updatePermissionTemplate(session, new PermissionTemplateNewValue(permissionTemplate)); | |||
return permissionTemplate; | |||
} | |||
@@ -197,10 +187,7 @@ public class PermissionTemplateDao implements Dao { | |||
mapper(session).insertUserPermission(permissionTemplateUser); | |||
if (auditPersister != null) { | |||
auditPersister.addUserToPermissionTemplate(session, new PermissionTemplateNewValue(templateUuid, templateName, | |||
permission, userUuid, userLogin, null, null)); | |||
} | |||
auditPersister.addUserToPermissionTemplate(session, new PermissionTemplateNewValue(templateUuid, templateName, permission, userUuid, userLogin, null, null)); | |||
session.commit(); | |||
} | |||
@@ -213,9 +200,8 @@ public class PermissionTemplateDao implements Dao { | |||
.setUserUuid(userUuid); | |||
int deletedRows = mapper(session).deleteUserPermission(permissionTemplateUser); | |||
if (deletedRows > 0 && auditPersister != null) { | |||
auditPersister.deleteUserFromPermissionTemplate(session, new PermissionTemplateNewValue(templateUuid, templateName, | |||
permission, userUuid, userLogin, null, null)); | |||
if (deletedRows > 0) { | |||
auditPersister.deleteUserFromPermissionTemplate(session, new PermissionTemplateNewValue(templateUuid, templateName, permission, userUuid, userLogin, null, null)); | |||
} | |||
session.commit(); | |||
@@ -224,9 +210,8 @@ public class PermissionTemplateDao implements Dao { | |||
public void deleteUserPermissionsByUserUuid(DbSession dbSession, String userUuid, String userLogin) { | |||
int deletedRows = mapper(dbSession).deleteUserPermissionsByUserUuid(userUuid); | |||
if (deletedRows > 0 && auditPersister != null) { | |||
auditPersister.deleteUserFromPermissionTemplate(dbSession, new PermissionTemplateNewValue(null, null, | |||
null, userUuid, userLogin, null, null)); | |||
if (deletedRows > 0) { | |||
auditPersister.deleteUserFromPermissionTemplate(dbSession, new PermissionTemplateNewValue(null, null, null, userUuid, userLogin, null, null)); | |||
} | |||
} | |||
@@ -241,19 +226,14 @@ public class PermissionTemplateDao implements Dao { | |||
.setUpdatedAt(now()); | |||
mapper(session).insertGroupPermission(permissionTemplateGroup); | |||
if (auditPersister != null) { | |||
auditPersister.addGroupToPermissionTemplate(session, new PermissionTemplateNewValue(templateUuid, templateName, | |||
permission, null, null, groupUuid, groupName)); | |||
} | |||
auditPersister.addGroupToPermissionTemplate(session, new PermissionTemplateNewValue(templateUuid, templateName, permission, null, null, groupUuid, groupName)); | |||
} | |||
public void insertGroupPermission(DbSession session, PermissionTemplateGroupDto permissionTemplateGroup, String templateName) { | |||
mapper(session).insertGroupPermission(permissionTemplateGroup); | |||
if (auditPersister != null) { | |||
auditPersister.addGroupToPermissionTemplate(session, new PermissionTemplateNewValue(permissionTemplateGroup.getTemplateUuid(), templateName, | |||
permissionTemplateGroup.getPermission(), null, null, permissionTemplateGroup.getGroupUuid(), permissionTemplateGroup.getGroupName())); | |||
} | |||
auditPersister.addGroupToPermissionTemplate(session, new PermissionTemplateNewValue(permissionTemplateGroup.getTemplateUuid(), templateName, | |||
permissionTemplateGroup.getPermission(), null, null, permissionTemplateGroup.getGroupUuid(), permissionTemplateGroup.getGroupName())); | |||
} | |||
public void deleteGroupPermission(DbSession session, String templateUuid, @Nullable String groupUuid, String permission, String templateName, | |||
@@ -264,7 +244,7 @@ public class PermissionTemplateDao implements Dao { | |||
.setGroupUuid(groupUuid); | |||
int deletedRows = mapper(session).deleteGroupPermission(permissionTemplateGroup); | |||
if (deletedRows > 0 && auditPersister != null) { | |||
if (deletedRows > 0) { | |||
auditPersister.deleteGroupFromPermissionTemplate(session, new PermissionTemplateNewValue(permissionTemplateGroup.getTemplateUuid(), templateName, | |||
permissionTemplateGroup.getPermission(), null, null, permissionTemplateGroup.getGroupUuid(), groupName)); | |||
} | |||
@@ -286,9 +266,8 @@ public class PermissionTemplateDao implements Dao { | |||
public void deleteByGroup(DbSession session, String groupUuid, String groupName) { | |||
int deletedRows = session.getMapper(PermissionTemplateMapper.class).deleteByGroupUuid(groupUuid); | |||
if (deletedRows > 0 && auditPersister != null) { | |||
auditPersister.deleteGroupFromPermissionTemplate(session, new PermissionTemplateNewValue(null, null, | |||
null, null, null, groupUuid, groupName)); | |||
if (deletedRows > 0) { | |||
auditPersister.deleteGroupFromPermissionTemplate(session, new PermissionTemplateNewValue(null, null, null, null, null, groupUuid, groupName)); | |||
} | |||
} | |||
@@ -27,11 +27,7 @@ import org.sonar.db.audit.AuditPersister; | |||
import org.sonar.db.audit.model.PluginNewValue; | |||
public class PluginDao implements Dao { | |||
private AuditPersister auditPersister; | |||
public PluginDao() { | |||
} | |||
private final AuditPersister auditPersister; | |||
public PluginDao(AuditPersister auditPersister) { | |||
this.auditPersister = auditPersister; | |||
@@ -53,18 +49,12 @@ public class PluginDao implements Dao { | |||
public void insert(DbSession dbSession, PluginDto dto) { | |||
mapper(dbSession).insert(dto); | |||
if (auditPersister != null) { | |||
auditPersister.addPlugin(dbSession, new PluginNewValue(dto)); | |||
} | |||
auditPersister.addPlugin(dbSession, new PluginNewValue(dto)); | |||
} | |||
public void update(DbSession dbSession, PluginDto dto) { | |||
mapper(dbSession).update(dto); | |||
if (auditPersister != null) { | |||
auditPersister.updatePlugin(dbSession, new PluginNewValue(dto)); | |||
} | |||
auditPersister.updatePlugin(dbSession, new PluginNewValue(dto)); | |||
} | |||
private static PluginMapper mapper(DbSession dbSession) { |
@@ -31,11 +31,7 @@ import org.sonar.db.audit.model.ComponentNewValue; | |||
public class ProjectDao implements Dao { | |||
private final System2 system2; | |||
private AuditPersister auditPersister; | |||
public ProjectDao(System2 system2) { | |||
this.system2 = system2; | |||
} | |||
private final AuditPersister auditPersister; | |||
public ProjectDao(System2 system2, AuditPersister auditPersister) { | |||
this.system2 = system2; | |||
@@ -47,9 +43,8 @@ public class ProjectDao implements Dao { | |||
} | |||
public void insert(DbSession session, ProjectDto project, boolean track) { | |||
if (track && auditPersister != null) { | |||
auditPersister.addComponent(session, new ComponentNewValue(project.getUuid(), project.getName(), project.getKey(), project.getQualifier()), | |||
project.getQualifier()); | |||
if (track) { | |||
auditPersister.addComponent(session, new ComponentNewValue(project)); | |||
} | |||
mapper(session).insert(project); | |||
} | |||
@@ -112,11 +107,7 @@ public class ProjectDao implements Dao { | |||
} | |||
public void update(DbSession session, ProjectDto project) { | |||
if (auditPersister != null) { | |||
auditPersister.updateComponent(session, new ComponentNewValue(project.getUuid(), project.isPrivate(), | |||
project.getName(), project.getKey(), project.getDescription(), project.getQualifier()), project.getQualifier()); | |||
} | |||
auditPersister.updateComponent(session, new ComponentNewValue(project)); | |||
mapper(session).update(project); | |||
} | |||
@@ -55,16 +55,12 @@ public class PropertiesDao implements Dao { | |||
private final MyBatis mybatis; | |||
private final System2 system2; | |||
private final UuidFactory uuidFactory; | |||
private AuditPersister auditPersister; | |||
private final AuditPersister auditPersister; | |||
public PropertiesDao(MyBatis mybatis, System2 system2, UuidFactory uuidFactory) { | |||
public PropertiesDao(MyBatis mybatis, System2 system2, UuidFactory uuidFactory, AuditPersister auditPersister) { | |||
this.mybatis = mybatis; | |||
this.system2 = system2; | |||
this.uuidFactory = uuidFactory; | |||
} | |||
public PropertiesDao(MyBatis mybatis, System2 system2, UuidFactory uuidFactory, AuditPersister auditPersister) { | |||
this(mybatis, system2, uuidFactory); | |||
this.auditPersister = auditPersister; | |||
} | |||
@@ -109,9 +105,9 @@ public class PropertiesDao implements Dao { | |||
} | |||
try (DbSession session = mybatis.openSession(false); | |||
Connection connection = session.getConnection(); | |||
PreparedStatement pstmt = createStatement(projectUuid, dispatcherKeys, connection); | |||
ResultSet rs = pstmt.executeQuery()) { | |||
Connection connection = session.getConnection(); | |||
PreparedStatement pstmt = createStatement(projectUuid, dispatcherKeys, connection); | |||
ResultSet rs = pstmt.executeQuery()) { | |||
return rs.next() && rs.getInt(1) > 0; | |||
} catch (SQLException e) { | |||
throw new IllegalStateException("Fail to execute SQL for hasProjectNotificationSubscribersForDispatchers", e); | |||
@@ -214,16 +210,14 @@ public class PropertiesDao implements Dao { | |||
saveProperty(session, property, null, null, null, null); | |||
} | |||
public void saveProperty(DbSession session, PropertyDto property, @Nullable String userLogin, @Nullable String projectKey, | |||
@Nullable String projectName, @Nullable String qualifier) { | |||
public void saveProperty(DbSession session, PropertyDto property, @Nullable String userLogin, @Nullable String projectKey, @Nullable String projectName, | |||
@Nullable String qualifier) { | |||
int affectedRows = save(getMapper(session), property.getKey(), property.getUserUuid(), property.getComponentUuid(), property.getValue()); | |||
if (auditPersister != null && auditPersister.isTrackedProperty(property.getKey())) { | |||
if (affectedRows > 0) { | |||
auditPersister.updateProperty(session, new PropertyNewValue(property, userLogin, projectKey, projectName, qualifier), false); | |||
} else { | |||
auditPersister.addProperty(session, new PropertyNewValue(property, userLogin, projectKey, projectName, qualifier), false); | |||
} | |||
if (affectedRows > 0) { | |||
auditPersister.updateProperty(session, new PropertyNewValue(property, userLogin, projectKey, projectName, qualifier), false); | |||
} else { | |||
auditPersister.addProperty(session, new PropertyNewValue(property, userLogin, projectKey, projectName, qualifier), false); | |||
} | |||
} | |||
@@ -272,7 +266,7 @@ public class PropertiesDao implements Dao { | |||
public int deleteByQuery(DbSession dbSession, PropertyQuery query) { | |||
int deletedRows = getMapper(dbSession).deleteByQuery(query); | |||
if (deletedRows > 0 && auditPersister != null && query.key() != null && auditPersister.isTrackedProperty(query.key())) { | |||
if (deletedRows > 0 && query.key() != null) { | |||
auditPersister.deleteProperty(dbSession, new PropertyNewValue(query.key(), query.componentUuid(), | |||
null, null, null, query.userUuid()), false); | |||
} | |||
@@ -284,7 +278,7 @@ public class PropertiesDao implements Dao { | |||
@Nullable String projectName, @Nullable String qualifier) { | |||
int deletedRows = getMapper(dbSession).delete(dto.getKey(), dto.getUserUuid(), dto.getComponentUuid()); | |||
if (deletedRows > 0 && auditPersister != null && auditPersister.isTrackedProperty(dto.getKey())) { | |||
if (deletedRows > 0) { | |||
auditPersister.deleteProperty(dbSession, new PropertyNewValue(dto, userLogin, projectKey, projectName, qualifier), | |||
false); | |||
} | |||
@@ -302,7 +296,7 @@ public class PropertiesDao implements Dao { | |||
String projectName, String qualifier) { | |||
int deletedRows = getMapper(session).deleteProjectProperty(key, projectUuid); | |||
if (deletedRows > 0 && auditPersister != null && auditPersister.isTrackedProperty(key)) { | |||
if (deletedRows > 0) { | |||
auditPersister.deleteProperty(session, new PropertyNewValue(key, projectUuid, projectKey, projectName, qualifier, | |||
null), false); | |||
} | |||
@@ -311,7 +305,7 @@ public class PropertiesDao implements Dao { | |||
public void deleteProjectProperties(String key, String value, DbSession session) { | |||
int deletedRows = getMapper(session).deleteProjectProperties(key, value); | |||
if (deletedRows > 0 && auditPersister != null && auditPersister.isTrackedProperty(key)) { | |||
if (deletedRows > 0) { | |||
auditPersister.deleteProperty(session, new PropertyNewValue(key, value), false); | |||
} | |||
} | |||
@@ -326,7 +320,7 @@ public class PropertiesDao implements Dao { | |||
public void deleteGlobalProperty(String key, DbSession session) { | |||
int deletedRows = getMapper(session).deleteGlobalProperty(key); | |||
if (deletedRows > 0 && auditPersister != null && auditPersister.isTrackedProperty(key)) { | |||
if (deletedRows > 0) { | |||
auditPersister.deleteProperty(session, new PropertyNewValue(key), false); | |||
} | |||
} | |||
@@ -357,7 +351,7 @@ public class PropertiesDao implements Dao { | |||
public void deleteByKeyAndValue(DbSession dbSession, String key, String value) { | |||
int deletedRows = getMapper(dbSession).deleteByKeyAndValue(key, value); | |||
if (deletedRows > 0 && auditPersister != null && auditPersister.isTrackedProperty(key)) { | |||
if (deletedRows > 0) { | |||
auditPersister.deleteProperty(dbSession, new PropertyNewValue(key, value), false); | |||
} | |||
} | |||
@@ -368,7 +362,7 @@ public class PropertiesDao implements Dao { | |||
properties.forEach((key, value) -> { | |||
int affectedRows = save(mapper, key, null, null, value); | |||
if (auditPersister != null && auditPersister.isTrackedProperty(key)) { | |||
if (auditPersister.isTrackedProperty(key)) { | |||
if (affectedRows > 0) { | |||
auditPersister.updateProperty(session, new PropertyNewValue(key, value), false); | |||
} else { | |||
@@ -397,7 +391,7 @@ public class PropertiesDao implements Dao { | |||
} | |||
private void persistDeletedProperties(DbSession dbSession, @Nullable String userUuid, String userLogin, List<String> uuids) { | |||
if (!uuids.isEmpty() && auditPersister != null) { | |||
if (!uuids.isEmpty()) { | |||
List<PropertyDto> properties = executeLargeInputs(uuids, subList -> getMapper(dbSession).selectByUuids(subList)); | |||
properties |
@@ -54,11 +54,7 @@ public class PurgeDao implements Dao { | |||
private static final String SCOPE_PROJECT = "PRJ"; | |||
private final System2 system2; | |||
private AuditPersister auditPersister; | |||
public PurgeDao(System2 system2) { | |||
this.system2 = system2; | |||
} | |||
private final AuditPersister auditPersister; | |||
public PurgeDao(System2 system2, AuditPersister auditPersister) { | |||
this.system2 = system2; | |||
@@ -195,19 +191,14 @@ public class PurgeDao implements Dao { | |||
long start = System2.INSTANCE.now(); | |||
List<String> branchUuids = session.getMapper(BranchMapper.class).selectByProjectUuid(uuid).stream() | |||
.filter(branch -> !uuid.equals(branch.getUuid())) | |||
.map(BranchDto::getUuid) | |||
.filter(branchUuid -> !uuid.equals(branchUuid)) | |||
.collect(Collectors.toList()); | |||
branchUuids.stream() | |||
.forEach(id -> deleteRootComponent(id, purgeMapper, purgeCommands)); | |||
branchUuids.forEach(id -> deleteRootComponent(id, purgeMapper, purgeCommands)); | |||
deleteRootComponent(uuid, purgeMapper, purgeCommands); | |||
if (auditPersister != null) { | |||
auditPersister.deleteComponent(session, new ComponentNewValue(uuid, name, key, qualifier), qualifier); | |||
} | |||
auditPersister.deleteComponent(session, new ComponentNewValue(uuid, name, key, qualifier)); | |||
logProfiling(profiler, start); | |||
} | |||
@@ -41,14 +41,10 @@ import static org.sonar.db.DatabaseUtils.executeLargeInputs; | |||
public class GroupDao implements Dao { | |||
private final System2 system; | |||
private AuditPersister auditPersister; | |||
public GroupDao(System2 system) { | |||
this.system = system; | |||
} | |||
private final AuditPersister auditPersister; | |||
public GroupDao(System2 system, AuditPersister auditPersister) { | |||
this(system); | |||
this.system = system; | |||
this.auditPersister = auditPersister; | |||
} | |||
@@ -77,7 +73,7 @@ public class GroupDao implements Dao { | |||
public void deleteByUuid(DbSession dbSession, String groupUuid, String groupName) { | |||
int deletedRows = mapper(dbSession).deleteByUuid(groupUuid); | |||
if (deletedRows > 0 && auditPersister != null) { | |||
if (deletedRows > 0) { | |||
auditPersister.deleteUserGroup(dbSession, new UserGroupNewValue(groupUuid, groupName)); | |||
} | |||
} | |||
@@ -95,22 +91,14 @@ public class GroupDao implements Dao { | |||
item.setCreatedAt(createdAt) | |||
.setUpdatedAt(createdAt); | |||
mapper(session).insert(item); | |||
if (auditPersister != null) { | |||
auditPersister.addUserGroup(session, new UserGroupNewValue(item.getUuid(), item.getName())); | |||
} | |||
auditPersister.addUserGroup(session, new UserGroupNewValue(item.getUuid(), item.getName())); | |||
return item; | |||
} | |||
public GroupDto update(DbSession session, GroupDto item) { | |||
item.setUpdatedAt(new Date(system.now())); | |||
mapper(session).update(item); | |||
if (auditPersister != null) { | |||
auditPersister.updateUserGroup(session, new UserGroupNewValue(item)); | |||
} | |||
auditPersister.updateUserGroup(session, new UserGroupNewValue(item)); | |||
return item; | |||
} | |||
@@ -49,16 +49,11 @@ public class UserDao implements Dao { | |||
private static final long WEEK_IN_MS = DAYS.toMillis(7L); | |||
private final System2 system2; | |||
private final UuidFactory uuidFactory; | |||
private final AuditPersister auditPersister; | |||
private AuditPersister auditPersister; | |||
public UserDao(System2 system2, UuidFactory uuidFactory) { | |||
public UserDao(System2 system2, UuidFactory uuidFactory, AuditPersister auditPersister) { | |||
this.system2 = system2; | |||
this.uuidFactory = uuidFactory; | |||
} | |||
public UserDao(System2 system2, UuidFactory uuidFactory, AuditPersister auditPersister) { | |||
this(system2, uuidFactory); | |||
this.auditPersister = auditPersister; | |||
} | |||
@@ -114,11 +109,7 @@ public class UserDao implements Dao { | |||
public UserDto insert(DbSession session, UserDto dto) { | |||
long now = system2.now(); | |||
mapper(session).insert(dto.setUuid(uuidFactory.create()).setCreatedAt(now).setUpdatedAt(now)); | |||
if (auditPersister != null) { | |||
auditPersister.addUser(session, new UserNewValue(dto.getUuid(), dto.getLogin())); | |||
} | |||
auditPersister.addUser(session, new UserNewValue(dto.getUuid(), dto.getLogin())); | |||
return dto; | |||
} | |||
@@ -128,7 +119,7 @@ public class UserDao implements Dao { | |||
public UserDto update(DbSession session, UserDto dto, boolean track) { | |||
mapper(session).update(dto.setUpdatedAt(system2.now())); | |||
if (track && auditPersister != null) { | |||
if (track) { | |||
auditPersister.updateUser(session, new UserNewValue(dto)); | |||
} | |||
return dto; | |||
@@ -144,10 +135,7 @@ public class UserDao implements Dao { | |||
public void deactivateUser(DbSession dbSession, UserDto user) { | |||
mapper(dbSession).deactivateUser(user.getLogin(), system2.now()); | |||
if (auditPersister != null) { | |||
auditPersister.deactivateUser(dbSession, new UserNewValue(user.getUuid(), user.getLogin())); | |||
} | |||
auditPersister.deactivateUser(dbSession, new UserNewValue(user.getUuid(), user.getLogin())); | |||
} | |||
public void cleanHomepage(DbSession dbSession, ProjectDto project) { |
@@ -26,11 +26,7 @@ import org.sonar.db.audit.AuditPersister; | |||
import org.sonar.db.audit.model.UserGroupNewValue; | |||
public class UserGroupDao implements Dao { | |||
private AuditPersister auditPersister; | |||
public UserGroupDao() { | |||
} | |||
private final AuditPersister auditPersister; | |||
public UserGroupDao(AuditPersister auditPersister) { | |||
this.auditPersister = auditPersister; | |||
@@ -38,11 +34,7 @@ public class UserGroupDao implements Dao { | |||
public UserGroupDto insert(DbSession session, UserGroupDto dto, String groupName, String login) { | |||
mapper(session).insert(dto); | |||
if (auditPersister != null) { | |||
auditPersister.addUserToGroup(session, new UserGroupNewValue(dto, groupName, login)); | |||
} | |||
auditPersister.addUserToGroup(session, new UserGroupNewValue(dto, groupName, login)); | |||
return dto; | |||
} | |||
@@ -53,7 +45,7 @@ public class UserGroupDao implements Dao { | |||
public void delete(DbSession session, GroupDto group, UserDto user) { | |||
int deletedRows = mapper(session).delete(group.getUuid(), user.getUuid()); | |||
if (deletedRows > 0 && auditPersister != null) { | |||
if (deletedRows > 0) { | |||
auditPersister.deleteUserFromGroup(session, new UserGroupNewValue(group, user)); | |||
} | |||
} | |||
@@ -61,7 +53,7 @@ public class UserGroupDao implements Dao { | |||
public void deleteByGroupUuid(DbSession session, String groupUuid, String groupName) { | |||
int deletedRows = mapper(session).deleteByGroupUuid(groupUuid); | |||
if (deletedRows > 0 && auditPersister != null) { | |||
if (deletedRows > 0) { | |||
auditPersister.deleteUserFromGroup(session, new UserGroupNewValue(groupUuid, groupName)); | |||
} | |||
} | |||
@@ -69,7 +61,7 @@ public class UserGroupDao implements Dao { | |||
public void deleteByUserUuid(DbSession dbSession, UserDto userDto) { | |||
int deletedRows = mapper(dbSession).deleteByUserUuid(userDto.getUuid()); | |||
if (deletedRows > 0 && auditPersister != null) { | |||
if (deletedRows > 0) { | |||
auditPersister.deleteUserFromGroup(dbSession, new UserGroupNewValue(userDto)); | |||
} | |||
} |
@@ -32,16 +32,11 @@ public class UserPropertiesDao implements Dao { | |||
private final System2 system2; | |||
private final UuidFactory uuidFactory; | |||
private final AuditPersister auditPersister; | |||
private AuditPersister auditPersister; | |||
public UserPropertiesDao(System2 system2, UuidFactory uuidFactory) { | |||
public UserPropertiesDao(System2 system2, UuidFactory uuidFactory, AuditPersister auditPersister) { | |||
this.system2 = system2; | |||
this.uuidFactory = uuidFactory; | |||
} | |||
public UserPropertiesDao(System2 system2, UuidFactory uuidFactory, AuditPersister auditPersister) { | |||
this(system2, uuidFactory); | |||
this.auditPersister = auditPersister; | |||
} | |||
@@ -57,12 +52,10 @@ public class UserPropertiesDao implements Dao { | |||
isUpdate = false; | |||
} | |||
if (auditPersister != null && auditPersister.isTrackedProperty(dto.getKey())) { | |||
if (isUpdate) { | |||
auditPersister.updateProperty(session, new PropertyNewValue(dto, login), true); | |||
} else { | |||
auditPersister.addProperty(session, new PropertyNewValue(dto, login), true); | |||
} | |||
if (isUpdate) { | |||
auditPersister.updateProperty(session, new PropertyNewValue(dto, login), true); | |||
} else { | |||
auditPersister.addProperty(session, new PropertyNewValue(dto, login), true); | |||
} | |||
return dto; | |||
@@ -72,7 +65,7 @@ public class UserPropertiesDao implements Dao { | |||
List<UserPropertyDto> userProperties = selectByUser(session, user); | |||
int deletedRows = mapper(session).deleteByUserUuid(user.getUuid()); | |||
if (deletedRows > 0 && auditPersister != null) { | |||
if (deletedRows > 0) { | |||
userProperties.stream() | |||
.filter(p -> auditPersister.isTrackedProperty(p.getKey())) | |||
.forEach(p -> auditPersister.deleteProperty(session, new PropertyNewValue(p, user.getLogin()), true)); |
@@ -35,38 +35,27 @@ import static org.sonar.core.util.stream.MoreCollectors.toList; | |||
import static org.sonar.db.DatabaseUtils.executeLargeInputs; | |||
public class UserTokenDao implements Dao { | |||
private UuidFactory uuidFactory; | |||
private AuditPersister auditPersister; | |||
public UserTokenDao(UuidFactory uuidFactory) { | |||
this.uuidFactory = uuidFactory; | |||
} | |||
private final UuidFactory uuidFactory; | |||
private final AuditPersister auditPersister; | |||
public UserTokenDao(UuidFactory uuidFactory, AuditPersister auditPersister) { | |||
this(uuidFactory); | |||
this.uuidFactory = uuidFactory; | |||
this.auditPersister = auditPersister; | |||
} | |||
public void insert(DbSession dbSession, UserTokenDto userTokenDto, String userLogin) { | |||
userTokenDto.setUuid(uuidFactory.create()); | |||
mapper(dbSession).insert(userTokenDto); | |||
if (auditPersister != null) { | |||
auditPersister.addUserToken(dbSession, new UserTokenNewValue(userTokenDto, userLogin)); | |||
} | |||
auditPersister.addUserToken(dbSession, new UserTokenNewValue(userTokenDto, userLogin)); | |||
} | |||
public void update(DbSession session, UserTokenDto userTokenDto, @Nullable String userLogin) { | |||
update(session, userTokenDto, true, userLogin); | |||
public void update(DbSession dbSession, UserTokenDto userTokenDto, @Nullable String userLogin) { | |||
mapper(dbSession).update(userTokenDto); | |||
auditPersister.updateUserToken(dbSession, new UserTokenNewValue(userTokenDto, userLogin)); | |||
} | |||
public void update(DbSession dbSession, UserTokenDto userTokenDto, boolean track, @Nullable String userLogin) { | |||
public void updateWithoutAudit(DbSession dbSession, UserTokenDto userTokenDto) { | |||
mapper(dbSession).update(userTokenDto); | |||
if (track && auditPersister != null) { | |||
auditPersister.updateUserToken(dbSession, new UserTokenNewValue(userTokenDto, userLogin)); | |||
} | |||
} | |||
@CheckForNull | |||
@@ -101,7 +90,7 @@ public class UserTokenDao implements Dao { | |||
public void deleteByUser(DbSession dbSession, UserDto user) { | |||
int deletedRows = mapper(dbSession).deleteByUserUuid(user.getUuid()); | |||
if (deletedRows > 0 && auditPersister != null) { | |||
if (deletedRows > 0) { | |||
auditPersister.deleteUserToken(dbSession, new UserTokenNewValue(user)); | |||
} | |||
} | |||
@@ -109,7 +98,7 @@ public class UserTokenDao implements Dao { | |||
public void deleteByUserAndName(DbSession dbSession, UserDto user, String name) { | |||
int deletedRows = mapper(dbSession).deleteByUserUuidAndName(user.getUuid(), name); | |||
if (deletedRows > 0 && auditPersister != null) { | |||
if (deletedRows > 0) { | |||
auditPersister.deleteUserToken(dbSession, new UserTokenNewValue(user, name)); | |||
} | |||
} |
@@ -33,11 +33,7 @@ import org.sonar.db.project.ProjectDto; | |||
public class WebhookDao implements Dao { | |||
private final System2 system2; | |||
private AuditPersister auditPersister; | |||
public WebhookDao(System2 system2) { | |||
this.system2 = system2; | |||
} | |||
private final AuditPersister auditPersister; | |||
public WebhookDao(System2 system2, AuditPersister auditPersister) { | |||
this.system2 = system2; | |||
@@ -58,27 +54,21 @@ public class WebhookDao implements Dao { | |||
public void insert(DbSession dbSession, WebhookDto dto, @Nullable String projectKey, @Nullable String projectName) { | |||
mapper(dbSession).insert(dto.setCreatedAt(system2.now()).setUpdatedAt(system2.now())); | |||
if (auditPersister != null) { | |||
auditPersister.addWebhook(dbSession, new WebhookNewValue(dto, projectKey, projectName)); | |||
} | |||
auditPersister.addWebhook(dbSession, new WebhookNewValue(dto, projectKey, projectName)); | |||
} | |||
public void update(DbSession dbSession, WebhookDto dto, @Nullable String projectKey, @Nullable String projectName) { | |||
mapper(dbSession).update(dto.setUpdatedAt(system2.now())); | |||
if (auditPersister != null) { | |||
if (dto.getSecret() != null) { | |||
auditPersister.updateWebhookSecret(dbSession, new SecretNewValue("webhook_name", dto.getName())); | |||
} | |||
auditPersister.updateWebhook(dbSession, new WebhookNewValue(dto, projectKey, projectName)); | |||
if (dto.getSecret() != null) { | |||
auditPersister.updateWebhookSecret(dbSession, new SecretNewValue("webhook_name", dto.getName())); | |||
} | |||
auditPersister.updateWebhook(dbSession, new WebhookNewValue(dto, projectKey, projectName)); | |||
} | |||
public void delete(DbSession dbSession, String uuid, String webhookName) { | |||
int deletedRows = mapper(dbSession).delete(uuid); | |||
if (deletedRows > 0 && auditPersister != null) { | |||
if (deletedRows > 0) { | |||
auditPersister.deleteWebhook(dbSession, new WebhookNewValue(uuid, webhookName)); | |||
} | |||
} | |||
@@ -86,7 +76,7 @@ public class WebhookDao implements Dao { | |||
public void deleteByProject(DbSession dbSession, ProjectDto projectDto) { | |||
int deletedRows = mapper(dbSession).deleteForProjectUuid(projectDto.getUuid()); | |||
if (deletedRows > 0 && auditPersister != null) { | |||
if (deletedRows > 0) { | |||
auditPersister.deleteWebhook(dbSession, new WebhookNewValue(projectDto)); | |||
} | |||
} |
@@ -27,6 +27,7 @@ import org.sonar.db.DbSession; | |||
import org.sonar.db.DbTester; | |||
import org.sonar.db.alm.setting.AlmSettingDao; | |||
import org.sonar.db.alm.setting.AlmSettingDto; | |||
import org.sonar.db.audit.NoOpAuditPersister; | |||
import org.sonar.db.user.UserDto; | |||
import static org.apache.commons.lang.RandomStringUtils.randomAlphanumeric; | |||
@@ -46,9 +47,9 @@ public class AlmPatDaoTest { | |||
private DbSession dbSession = db.getSession(); | |||
private UuidFactory uuidFactory = mock(UuidFactory.class); | |||
private AlmSettingDao almSettingDao = new AlmSettingDao(system2, uuidFactory); | |||
private AlmSettingDao almSettingDao = new AlmSettingDao(system2, uuidFactory, new NoOpAuditPersister()); | |||
private AlmPatDao underTest = new AlmPatDao(system2, uuidFactory); | |||
private AlmPatDao underTest = new AlmPatDao(system2, uuidFactory, new NoOpAuditPersister()); | |||
@Test | |||
public void selectByUuid() { |
@@ -34,6 +34,7 @@ import org.sonar.db.user.UserDto; | |||
import static org.assertj.core.api.Assertions.assertThat; | |||
import static org.mockito.ArgumentMatchers.any; | |||
import static org.mockito.ArgumentMatchers.eq; | |||
import static org.mockito.Mockito.clearInvocations; | |||
import static org.mockito.Mockito.mock; | |||
import static org.mockito.Mockito.verify; | |||
import static org.mockito.Mockito.verifyNoInteractions; | |||
@@ -45,16 +46,17 @@ public class AlmPatDaoWithPersisterTest { | |||
private static final long NOW = 1000000L; | |||
private static final String A_UUID = "SOME_UUID"; | |||
private final AuditPersister auditPersister = mock(AuditPersister.class); | |||
private final ArgumentCaptor<PersonalAccessTokenNewValue> newValueCaptor = ArgumentCaptor.forClass(PersonalAccessTokenNewValue.class); | |||
private TestSystem2 system2 = new TestSystem2().setNow(NOW); | |||
private final TestSystem2 system2 = new TestSystem2().setNow(NOW); | |||
@Rule | |||
public DbTester db = DbTester.create(system2, auditPersister); | |||
private DbSession dbSession = db.getSession(); | |||
private UuidFactory uuidFactory = mock(UuidFactory.class); | |||
private final DbSession dbSession = db.getSession(); | |||
private final UuidFactory uuidFactory = mock(UuidFactory.class); | |||
private AlmPatDao underTest = db.getDbClient().almPatDao(); | |||
private final AlmPatDao underTest = db.getDbClient().almPatDao(); | |||
@Test | |||
public void insertAndUpdateArePersisted() { | |||
@@ -164,7 +166,7 @@ public class AlmPatDaoWithPersisterTest { | |||
@Test | |||
public void deleteByAlmSettingWithoutAffectedRowsIsNotPersisted() { | |||
AlmSettingDto almSettingDto = db.almSettings().insertBitbucketAlmSetting(); | |||
clearInvocations(auditPersister); | |||
underTest.deleteByAlmSetting(dbSession, almSettingDto); | |||
verifyNoInteractions(auditPersister); |
@@ -27,6 +27,7 @@ import org.sonar.core.util.UuidFactory; | |||
import org.sonar.db.DbSession; | |||
import org.sonar.db.DbTester; | |||
import org.sonar.db.almsettings.AlmSettingsTesting; | |||
import org.sonar.db.audit.NoOpAuditPersister; | |||
import static org.assertj.core.api.Assertions.assertThat; | |||
import static org.mockito.Mockito.mock; | |||
@@ -44,7 +45,7 @@ public class AlmSettingDaoTest { | |||
private DbSession dbSession = db.getSession(); | |||
private UuidFactory uuidFactory = mock(UuidFactory.class); | |||
private AlmSettingDao underTest = new AlmSettingDao(system2, uuidFactory); | |||
private AlmSettingDao underTest = new AlmSettingDao(system2, uuidFactory, new NoOpAuditPersister()); | |||
@Test | |||
public void selectByUuid() { |
@@ -27,6 +27,7 @@ import org.sonar.api.impl.utils.TestSystem2; | |||
import org.sonar.core.util.UuidFactory; | |||
import org.sonar.db.DbSession; | |||
import org.sonar.db.DbTester; | |||
import org.sonar.db.audit.NoOpAuditPersister; | |||
import org.sonar.db.project.ProjectDto; | |||
import static org.assertj.core.api.Assertions.assertThat; | |||
@@ -48,7 +49,7 @@ public class ProjectAlmSettingDaoTest { | |||
private DbSession dbSession = db.getSession(); | |||
private UuidFactory uuidFactory = mock(UuidFactory.class); | |||
private ProjectAlmSettingDao underTest = new ProjectAlmSettingDao(system2, uuidFactory); | |||
private ProjectAlmSettingDao underTest = new ProjectAlmSettingDao(system2, uuidFactory, new NoOpAuditPersister()); | |||
@Test | |||
public void select_by_project() { |
@@ -24,6 +24,7 @@ import org.junit.Test; | |||
import org.mockito.ArgumentCaptor; | |||
import org.sonar.api.impl.utils.TestSystem2; | |||
import org.sonar.core.util.UuidFactory; | |||
import org.sonar.core.util.UuidFactoryFast; | |||
import org.sonar.db.DbSession; | |||
import org.sonar.db.DbTester; | |||
import org.sonar.db.audit.AuditPersister; | |||
@@ -38,6 +39,7 @@ import static org.mockito.Mockito.verify; | |||
import static org.mockito.Mockito.verifyNoInteractions; | |||
import static org.mockito.Mockito.verifyNoMoreInteractions; | |||
import static org.mockito.Mockito.when; | |||
import static org.sonar.db.almsettings.AlmSettingsTesting.newGithubAlmSettingDto; | |||
import static org.sonar.db.almsettings.AlmSettingsTesting.newGithubProjectAlmSettingDto; | |||
public class ProjectAlmSettingDaoWithPersisterTest { | |||
@@ -53,13 +55,12 @@ public class ProjectAlmSettingDaoWithPersisterTest { | |||
public final DbTester db = DbTester.create(system2, auditPersister); | |||
private final DbSession dbSession = db.getSession(); | |||
private final UuidFactory uuidFactory = mock(UuidFactory.class); | |||
private final UuidFactory uuidFactory = UuidFactoryFast.getInstance(); | |||
private final ProjectAlmSettingDao underTest = db.getDbClient().projectAlmSettingDao(); | |||
@Test | |||
public void insertAndUpdateExistingBindingArePersisted() { | |||
when(uuidFactory.create()).thenReturn(A_UUID); | |||
AlmSettingDto githubAlmSetting = db.almSettings().insertGitHubAlmSetting(); | |||
AlmSettingDto githubAlmSetting = newGithubAlmSettingDto().setUuid(uuidFactory.create()); | |||
ProjectDto project = db.components().insertPrivateProjectDto(); | |||
ProjectAlmSettingDto projectAlmSettingDto = newGithubProjectAlmSettingDto(githubAlmSetting, project) | |||
.setSummaryCommentEnabled(false); | |||
@@ -95,8 +96,7 @@ public class ProjectAlmSettingDaoWithPersisterTest { | |||
@Test | |||
public void deleteByProjectIsPersisted() { | |||
when(uuidFactory.create()).thenReturn(A_UUID); | |||
AlmSettingDto githubAlmSetting = db.almSettings().insertGitHubAlmSetting(); | |||
AlmSettingDto githubAlmSetting = newGithubAlmSettingDto().setUuid(uuidFactory.create()); | |||
ProjectDto project = db.components().insertPrivateProjectDto(); | |||
ProjectAlmSettingDto projectAlmSettingDto = newGithubProjectAlmSettingDto(githubAlmSetting, project) | |||
.setSummaryCommentEnabled(false); | |||
@@ -118,15 +118,7 @@ public class ProjectAlmSettingDaoWithPersisterTest { | |||
underTest.deleteByProject(dbSession, project); | |||
verify(auditPersister).addComponent(any(), any(), any()); | |||
verify(auditPersister).addComponent(any(), any()); | |||
verifyNoMoreInteractions(auditPersister); | |||
} | |||
@Test | |||
public void deleteByAlmSettingNotTrackedIsNotPersisted() { | |||
AlmSettingDto githubAlmSetting = db.almSettings().insertGitHubAlmSetting(); | |||
underTest.deleteByAlmSetting(dbSession, githubAlmSetting); | |||
verifyNoInteractions(auditPersister); | |||
} | |||
} |
@@ -42,7 +42,6 @@ import org.assertj.core.api.ListAssert; | |||
import org.junit.Rule; | |||
import org.junit.Test; | |||
import org.junit.runner.RunWith; | |||
import org.mockito.Mockito; | |||
import org.sonar.api.impl.utils.AlwaysIncreasingSystem2; | |||
import org.sonar.api.resources.Qualifiers; | |||
import org.sonar.api.resources.Scopes; | |||
@@ -51,6 +50,7 @@ import org.sonar.db.DbSession; | |||
import org.sonar.db.DbTester; | |||
import org.sonar.db.RowNotFoundException; | |||
import org.sonar.db.audit.AuditPersister; | |||
import org.sonar.db.audit.NoOpAuditPersister; | |||
import org.sonar.db.audit.model.ComponentNewValue; | |||
import org.sonar.db.issue.IssueDto; | |||
import org.sonar.db.metric.MetricDto; | |||
@@ -72,7 +72,6 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy; | |||
import static org.assertj.core.api.Assertions.entry; | |||
import static org.assertj.core.api.Assertions.tuple; | |||
import static org.mockito.ArgumentMatchers.any; | |||
import static org.mockito.ArgumentMatchers.anyString; | |||
import static org.mockito.Mockito.mock; | |||
import static org.mockito.Mockito.verify; | |||
import static org.mockito.Mockito.verifyNoInteractions; | |||
@@ -118,7 +117,7 @@ public class ComponentDaoTest { | |||
private final Random random = new Random(); | |||
private final DbSession dbSession = db.getSession(); | |||
private final ComponentDao underTest = new ComponentDao(); | |||
private final ComponentDao underTest = new ComponentDao(new NoOpAuditPersister()); | |||
private final ComponentDao underTestWithAuditPersister = new ComponentDao(auditPersister); | |||
private static ComponentTreeQuery.Builder newTreeQuery(String baseUuid) { | |||
@@ -1772,7 +1771,7 @@ public class ComponentDaoTest { | |||
db.components().insertComponent(newPrivateProjectDto().setRootUuid(uuid1).setProjectUuid("foo").setPrivate(false)).uuid(), | |||
}; | |||
underTest.setPrivateForRootComponentUuid(db.getSession(), uuid1, true, "key", null, "name", true); | |||
underTest.setPrivateForRootComponentUuidWithoutAudit(db.getSession(), uuid1, true); | |||
assertThat(privateFlagOfUuid(uuids[0])).isTrue(); | |||
assertThat(privateFlagOfUuid(uuids[1])).isTrue(); | |||
@@ -1780,7 +1779,7 @@ public class ComponentDaoTest { | |||
assertThat(privateFlagOfUuid(uuids[3])).isFalse(); | |||
assertThat(privateFlagOfUuid(uuids[4])).isFalse(); | |||
underTest.setPrivateForRootComponentUuid(db.getSession(), uuid1, false, "key", null, "name", true); | |||
underTest.setPrivateForRootComponentUuidWithoutAudit(db.getSession(), uuid1, false); | |||
assertThat(privateFlagOfUuid(uuids[0])).isFalse(); | |||
assertThat(privateFlagOfUuid(uuids[1])).isFalse(); | |||
@@ -1788,7 +1787,7 @@ public class ComponentDaoTest { | |||
assertThat(privateFlagOfUuid(uuids[3])).isFalse(); | |||
assertThat(privateFlagOfUuid(uuids[4])).isFalse(); | |||
underTest.setPrivateForRootComponentUuid(db.getSession(), uuid2, false, "key", null, "name", true); | |||
underTest.setPrivateForRootComponentUuidWithoutAudit(db.getSession(), uuid2, false); | |||
assertThat(privateFlagOfUuid(uuids[0])).isFalse(); | |||
assertThat(privateFlagOfUuid(uuids[1])).isFalse(); | |||
@@ -1796,7 +1795,7 @@ public class ComponentDaoTest { | |||
assertThat(privateFlagOfUuid(uuids[3])).isFalse(); | |||
assertThat(privateFlagOfUuid(uuids[4])).isFalse(); | |||
underTest.setPrivateForRootComponentUuid(db.getSession(), uuid2, true, "key", null, "name", true); | |||
underTest.setPrivateForRootComponentUuidWithoutAudit(db.getSession(), uuid2, true); | |||
assertThat(privateFlagOfUuid(uuids[0])).isFalse(); | |||
assertThat(privateFlagOfUuid(uuids[1])).isFalse(); | |||
@@ -1884,28 +1883,26 @@ public class ComponentDaoTest { | |||
@Test | |||
public void setPrivateForRootComponentUuid_auditPersisterIsCalled() { | |||
underTestWithAuditPersister.setPrivateForRootComponentUuid(dbSession, "anyUuid", false, "key", APP, "appName", true); | |||
underTestWithAuditPersister.setPrivateForRootComponentUuid(dbSession, "anyUuid", false, "key", APP, "appName"); | |||
verify(auditPersister, Mockito.times(1)) | |||
.updateComponentVisibility(any(DbSession.class), any(ComponentNewValue.class), anyString()); | |||
verify(auditPersister).updateComponentVisibility(any(DbSession.class), any(ComponentNewValue.class)); | |||
} | |||
@Test | |||
public void setPrivateForRootComponentUuid_withoutTrack_auditPersisterIsNotCalled() { | |||
underTestWithAuditPersister.setPrivateForRootComponentUuid(dbSession, "anyUuid", false, "key", APP, "appName", false); | |||
public void setPrivateForRootComponentUuidWithoutAudit_auditPersisterIsNotCalled() { | |||
underTestWithAuditPersister.setPrivateForRootComponentUuidWithoutAudit(dbSession, "anyUuid", false); | |||
verifyNoInteractions(auditPersister); | |||
} | |||
@Test | |||
public void update_auditPersisterIsCalled() { | |||
ComponentUpdateDto app = new ComponentUpdateDto(); | |||
ComponentUpdateDto app = new ComponentUpdateDto().setUuid("uuid"); | |||
app.setBQualifier(APP); | |||
underTestWithAuditPersister.update(dbSession, app, APP); | |||
verify(auditPersister, Mockito.times(1)) | |||
.updateComponent(any(DbSession.class), any(ComponentNewValue.class), anyString()); | |||
verify(auditPersister).updateComponent(any(DbSession.class), any(ComponentNewValue.class)); | |||
} | |||
@Test | |||
@@ -1914,8 +1911,7 @@ public class ComponentDaoTest { | |||
underTestWithAuditPersister.insert(dbSession, app); | |||
verify(auditPersister, Mockito.times(1)) | |||
.addComponent(any(DbSession.class), any(ComponentNewValue.class), anyString()); | |||
verify(auditPersister).addComponent(any(DbSession.class), any(ComponentNewValue.class)); | |||
} | |||
private boolean privateFlagOfUuid(String uuid) { |
@@ -35,6 +35,7 @@ import org.junit.runner.RunWith; | |||
import org.sonar.api.utils.System2; | |||
import org.sonar.db.DbSession; | |||
import org.sonar.db.DbTester; | |||
import org.sonar.db.audit.NoOpAuditPersister; | |||
import org.sonar.db.source.FileSourceDto; | |||
import static org.apache.commons.lang.RandomStringUtils.randomAlphabetic; | |||
@@ -50,7 +51,7 @@ public class ScrollForFileMoveComponentDaoTest { | |||
private Random random = new Random(); | |||
private DbSession dbSession = db.getSession(); | |||
private ComponentDao underTest = new ComponentDao(); | |||
private ComponentDao underTest = new ComponentDao(new NoOpAuditPersister()); | |||
@Test | |||
public void scrollAllFilesForFileMove_has_no_effect_if_project_does_not_exist() { |
@@ -33,6 +33,7 @@ import org.sonar.api.web.UserRole; | |||
import org.sonar.core.util.stream.MoreCollectors; | |||
import org.sonar.db.DbSession; | |||
import org.sonar.db.DbTester; | |||
import org.sonar.db.audit.NoOpAuditPersister; | |||
import org.sonar.db.component.ComponentDto; | |||
import org.sonar.db.user.GroupDto; | |||
@@ -59,7 +60,7 @@ public class GroupPermissionDaoTest { | |||
public DbTester db = DbTester.create(System2.INSTANCE); | |||
private final DbSession dbSession = db.getSession(); | |||
private final GroupPermissionDao underTest = new GroupPermissionDao(); | |||
private final GroupPermissionDao underTest = new GroupPermissionDao(new NoOpAuditPersister()); | |||
@Test | |||
public void group_count_by_permission_and_component_id_on_private_projects() { |
@@ -33,24 +33,22 @@ import org.sonar.db.component.ComponentDto; | |||
import org.sonar.db.user.GroupDto; | |||
import static org.assertj.core.api.Assertions.assertThat; | |||
import static org.mockito.ArgumentMatchers.any; | |||
import static org.mockito.ArgumentMatchers.eq; | |||
import static org.mockito.Mockito.mock; | |||
import static org.mockito.Mockito.verify; | |||
import static org.mockito.Mockito.verifyNoInteractions; | |||
import static org.mockito.Mockito.verifyNoMoreInteractions; | |||
import static org.sonar.api.web.UserRole.ADMIN; | |||
public class GroupPermissionDaoWithPersisterTest { | |||
private final AuditPersister auditPersister = mock(AuditPersister.class); | |||
@Rule | |||
public DbTester db = DbTester.create(System2.INSTANCE, auditPersister); | |||
public DbTester db = DbTester.create(System2.INSTANCE); | |||
private final SequenceUuidFactory uuidFactory = new SequenceUuidFactory(); | |||
private final ArgumentCaptor<GroupPermissionNewValue> newValueCaptor = ArgumentCaptor.forClass(GroupPermissionNewValue.class); | |||
private final DbSession dbSession = db.getSession(); | |||
private final GroupPermissionDao underTest = db.getDbClient().groupPermissionDao(); | |||
private final GroupPermissionDao underTest = new GroupPermissionDao(auditPersister); | |||
private GroupDto group; | |||
private ComponentDto project; | |||
@@ -87,7 +85,7 @@ public class GroupPermissionDaoWithPersisterTest { | |||
verify(auditPersister).addGroupPermission(eq(dbSession), newValueCaptor.capture()); | |||
GroupPermissionNewValue newValue = newValueCaptor.getValue(); | |||
assertNewValue(newValue, dto.getUuid(), group.getUuid(), group.getName(), project.uuid(), dto.getRole(), project.getKey(), | |||
project.name(), "project"); | |||
project.name(), "TRK"); | |||
assertThat(newValue).hasToString("{\"permissionUuid\": \"1\", \"permission\": \"admin\", \"groupUuid\": \"guuid\", \"groupName\": \"gname\"," + | |||
" \"componentUuid\": \"cuuid\", \"componentKey\": \"cKey\", \"componentName\": \"cname\", \"qualifier\": \"project\" }"); | |||
@@ -95,7 +93,7 @@ public class GroupPermissionDaoWithPersisterTest { | |||
verify(auditPersister).deleteGroupPermission(eq(dbSession), newValueCaptor.capture()); | |||
newValue = newValueCaptor.getValue(); | |||
assertNewValue(newValue, null, null, null, project.uuid(), null, project.getKey(), project.name(), "project"); | |||
assertNewValue(newValue, null, null, null, project.uuid(), null, project.getKey(), project.name(), "TRK"); | |||
assertThat(newValue).hasToString("{\"componentUuid\": \"cuuid\", \"componentKey\": \"cKey\", \"componentName\": \"cname\", \"qualifier\": \"project\" }"); | |||
} | |||
@@ -105,8 +103,7 @@ public class GroupPermissionDaoWithPersisterTest { | |||
underTest.deleteByRootComponentUuid(dbSession, project); | |||
verify(auditPersister).addComponent(any(), any(), any()); | |||
verifyNoMoreInteractions(auditPersister); | |||
verifyNoInteractions(auditPersister); | |||
} | |||
@Test | |||
@@ -115,7 +112,7 @@ public class GroupPermissionDaoWithPersisterTest { | |||
verify(auditPersister).addGroupPermission(eq(dbSession), newValueCaptor.capture()); | |||
GroupPermissionNewValue newValue = newValueCaptor.getValue(); | |||
assertNewValue(newValue, dto.getUuid(), null, null, project.uuid(), dto.getRole(), project.getKey(), project.name(), "project"); | |||
assertNewValue(newValue, dto.getUuid(), null, null, project.uuid(), dto.getRole(), project.getKey(), project.name(), "TRK"); | |||
assertThat(newValue).hasToString("{\"permissionUuid\": \"1\", \"permission\": \"admin\", \"componentUuid\": \"cuuid\", " | |||
+ "\"componentKey\": \"cKey\", \"componentName\": \"cname\", \"qualifier\": \"project\" }"); | |||
@@ -123,7 +120,7 @@ public class GroupPermissionDaoWithPersisterTest { | |||
verify(auditPersister).deleteGroupPermission(eq(dbSession), newValueCaptor.capture()); | |||
newValue = newValueCaptor.getValue(); | |||
assertNewValue(newValue, null, null, null, project.uuid(), null, project.getKey(), project.name(), "project"); | |||
assertNewValue(newValue, null, null, null, project.uuid(), null, project.getKey(), project.name(), "TRK"); | |||
assertThat(newValue).hasToString("{\"componentUuid\": \"cuuid\", \"componentKey\": \"cKey\", " + | |||
"\"componentName\": \"cname\", \"qualifier\": \"project\" }"); | |||
} | |||
@@ -134,8 +131,7 @@ public class GroupPermissionDaoWithPersisterTest { | |||
underTest.deleteByRootComponentUuidForAnyOne(dbSession, project); | |||
verify(auditPersister).addComponent(any(), any(), any()); | |||
verifyNoMoreInteractions(auditPersister); | |||
verifyNoInteractions(auditPersister); | |||
} | |||
@Test | |||
@@ -144,7 +140,7 @@ public class GroupPermissionDaoWithPersisterTest { | |||
verify(auditPersister).addGroupPermission(eq(dbSession), newValueCaptor.capture()); | |||
GroupPermissionNewValue newValue = newValueCaptor.getValue(); | |||
assertNewValue(newValue, dto.getUuid(), group.getUuid(), group.getName(), project.uuid(), dto.getRole(), project.getKey(), project.name(), "project"); | |||
assertNewValue(newValue, dto.getUuid(), group.getUuid(), group.getName(), project.uuid(), dto.getRole(), project.getKey(), project.name(), "TRK"); | |||
assertThat(newValue).hasToString("{\"permissionUuid\": \"1\", \"permission\": \"admin\", \"groupUuid\": \"guuid\", \"groupName\": \"gname\", " | |||
+ "\"componentUuid\": \"cuuid\", \"componentKey\": \"cKey\", \"componentName\": \"cname\", \"qualifier\": \"project\" }"); | |||
@@ -152,7 +148,7 @@ public class GroupPermissionDaoWithPersisterTest { | |||
verify(auditPersister).deleteGroupPermission(eq(dbSession), newValueCaptor.capture()); | |||
newValue = newValueCaptor.getValue(); | |||
assertNewValue(newValue, null, null, null, project.uuid(), ADMIN, project.getKey(), project.name(), "project"); | |||
assertNewValue(newValue, null, null, null, project.uuid(), ADMIN, project.getKey(), project.name(), "TRK"); | |||
assertThat(newValue).hasToString("{\"permission\": \"admin\", \"componentUuid\": \"cuuid\", \"componentKey\": \"cKey\"," + | |||
" \"componentName\": \"cname\", \"qualifier\": \"project\" }"); | |||
} | |||
@@ -165,17 +161,14 @@ public class GroupPermissionDaoWithPersisterTest { | |||
underTest.deleteByRootComponentUuidAndPermission(dbSession, dto.getRole(), project); | |||
verify(auditPersister).addComponent(any(), any(), any()); | |||
verifyNoMoreInteractions(auditPersister); | |||
verifyNoInteractions(auditPersister); | |||
} | |||
private void assertNewValue(GroupPermissionNewValue newValue, String uuid, String groupUuid, String groupName, String cUuid, String permission, | |||
String componentKey, String cName, String qualifier) { | |||
assertThat(newValue) | |||
.extracting("permissionUuid", "groupUuid", "groupName", "componentUuid", "permission", | |||
"componentKey", "componentName", "qualifier") | |||
.containsExactly(uuid, groupUuid, groupName, cUuid, permission, componentKey, | |||
cName, qualifier); | |||
.extracting("permissionUuid", "groupUuid", "groupName", "componentUuid", "permission", "componentKey", "componentName", "qualifier") | |||
.containsExactly(uuid, groupUuid, groupName, cUuid, permission, componentKey, cName, qualifier); | |||
} | |||
private void addGroupPermission() { |
@@ -34,6 +34,7 @@ import org.sonar.api.web.UserRole; | |||
import org.sonar.core.util.Uuids; | |||
import org.sonar.db.DbSession; | |||
import org.sonar.db.DbTester; | |||
import org.sonar.db.audit.NoOpAuditPersister; | |||
import org.sonar.db.component.ComponentDto; | |||
import org.sonar.db.user.UserDto; | |||
@@ -62,7 +63,7 @@ public class UserPermissionDaoTest { | |||
public DbTester db = DbTester.create(System2.INSTANCE); | |||
private DbSession dbSession = db.getSession(); | |||
private UserPermissionDao underTest = new UserPermissionDao(); | |||
private UserPermissionDao underTest = new UserPermissionDao(new NoOpAuditPersister()); | |||
@Test | |||
public void select_global_permissions() { |
@@ -92,16 +92,6 @@ public class UserPermissionDaoWithPersisterTest { | |||
assertThat(newValue.toString()).doesNotContain("projectUuid"); | |||
} | |||
@Test | |||
public void userGlobalPermissionDeleteWithoutAffectedRowsIsNotPersisted() { | |||
UserDto user = insertUser(u -> u.setLogin("login1").setName("Marius").setEmail("email1@email.com")); | |||
underTest.deleteGlobalPermission(dbSession, user, SYSTEM_ADMIN); | |||
verify(auditPersister).addUser(any(), any()); | |||
verifyNoMoreInteractions(auditPersister); | |||
} | |||
@Test | |||
public void userProjectPermissionInsertAndDeleteArePersisted() { | |||
UserDto user = insertUser(u -> u.setLogin("login1").setName("Marius").setEmail("email1@email.com")); | |||
@@ -112,7 +102,7 @@ public class UserPermissionDaoWithPersisterTest { | |||
verify(auditPersister).addUserPermission(eq(dbSession), newValueCaptor.capture()); | |||
UserPermissionNewValue newValue = newValueCaptor.getValue(); | |||
assertNewValue(newValue, dto.getUuid(), user.getUuid(), user.getLogin(), project.uuid(), dto.getPermission(), | |||
project.getKey(), project.name(), "project"); | |||
project.getKey(), project.name(), "TRK"); | |||
assertThat(newValue.toString()).contains("componentUuid"); | |||
underTest.deleteProjectPermission(dbSession, user, SYSTEM_ADMIN, project); | |||
@@ -120,7 +110,7 @@ public class UserPermissionDaoWithPersisterTest { | |||
verify(auditPersister).deleteUserPermission(eq(dbSession), newValueCaptor.capture()); | |||
newValue = newValueCaptor.getValue(); | |||
assertNewValue(newValue, null, user.getUuid(), user.getLogin(), project.uuid(), dto.getPermission(), | |||
project.getKey(), project.name(), "project"); | |||
project.getKey(), project.name(), "TRK"); | |||
assertThat(newValue.toString()).doesNotContain("permissionUuid"); | |||
} | |||
@@ -132,7 +122,7 @@ public class UserPermissionDaoWithPersisterTest { | |||
underTest.deleteProjectPermission(dbSession, user, SYSTEM_ADMIN, project); | |||
verify(auditPersister).addUser(any(), any()); | |||
verify(auditPersister).addComponent(any(), any(), any()); | |||
verify(auditPersister).addComponent(any(), any()); | |||
verifyNoMoreInteractions(auditPersister); | |||
} | |||
@@ -146,7 +136,7 @@ public class UserPermissionDaoWithPersisterTest { | |||
verify(auditPersister).addUserPermission(eq(dbSession), newValueCaptor.capture()); | |||
UserPermissionNewValue newValue = newValueCaptor.getValue(); | |||
assertNewValue(newValue, dto.getUuid(), user.getUuid(), user.getLogin(), portfolio.uuid(), dto.getPermission(), | |||
portfolio.getKey(), portfolio.name(), "portfolio"); | |||
portfolio.getKey(), portfolio.name(), "VW"); | |||
assertThat(newValue.toString()).contains("componentUuid"); | |||
} | |||
@@ -160,7 +150,7 @@ public class UserPermissionDaoWithPersisterTest { | |||
verify(auditPersister).addUserPermission(eq(dbSession), newValueCaptor.capture()); | |||
UserPermissionNewValue newValue = newValueCaptor.getValue(); | |||
assertNewValue(newValue, dto.getUuid(), user.getUuid(), user.getLogin(), application.uuid(), dto.getPermission(), | |||
application.getKey(), application.name(), "application"); | |||
application.getKey(), application.name(), "APP"); | |||
assertThat(newValue.toString()).contains("componentUuid"); | |||
} | |||
@@ -175,7 +165,7 @@ public class UserPermissionDaoWithPersisterTest { | |||
verify(auditPersister).deleteUserPermission(eq(dbSession), newValueCaptor.capture()); | |||
UserPermissionNewValue newValue = newValueCaptor.getValue(); | |||
assertNewValue(newValue, null, null, null, project.uuid(), dto.getPermission(), | |||
project.getKey(), project.name(), "project"); | |||
project.getKey(), project.name(), "TRK"); | |||
assertThat(newValue.toString()).doesNotContain("userUuid"); | |||
} | |||
@@ -185,7 +175,7 @@ public class UserPermissionDaoWithPersisterTest { | |||
underTest.deleteProjectPermissionOfAnyUser(dbSession, SCAN_EXECUTION, project); | |||
verify(auditPersister).addComponent(any(), any(), any()); | |||
verify(auditPersister).addComponent(any(), any()); | |||
verifyNoMoreInteractions(auditPersister); | |||
} | |||
@@ -27,6 +27,7 @@ import org.sonar.api.utils.System2; | |||
import org.sonar.api.web.UserRole; | |||
import org.sonar.db.DbSession; | |||
import org.sonar.db.DbTester; | |||
import org.sonar.db.audit.NoOpAuditPersister; | |||
import static com.google.common.collect.Lists.newArrayList; | |||
import static java.util.Arrays.asList; | |||
@@ -39,7 +40,7 @@ public class PermissionTemplateCharacteristicDaoTest { | |||
@Rule | |||
public DbTester db = DbTester.create(System2.INSTANCE); | |||
private final DbSession dbSession = db.getSession(); | |||
private final PermissionTemplateCharacteristicDao underTest = new PermissionTemplateCharacteristicDao(); | |||
private final PermissionTemplateCharacteristicDao underTest = new PermissionTemplateCharacteristicDao(new NoOpAuditPersister()); | |||
@Test | |||
public void selectByTemplateId_filter_by_template_uuid() { |
@@ -32,6 +32,7 @@ import org.sonar.core.util.UuidFactory; | |||
import org.sonar.core.util.UuidFactoryFast; | |||
import org.sonar.db.DbSession; | |||
import org.sonar.db.DbTester; | |||
import org.sonar.db.audit.NoOpAuditPersister; | |||
import org.sonar.db.user.GroupDto; | |||
import org.sonar.db.user.UserDto; | |||
@@ -63,7 +64,7 @@ public class PermissionTemplateDaoTest { | |||
private PermissionTemplateDbTester templateDb = db.permissionTemplates(); | |||
private UuidFactory uuidFactory = UuidFactoryFast.getInstance(); | |||
private PermissionTemplateDao underTest = new PermissionTemplateDao(uuidFactory, system2); | |||
private PermissionTemplateDao underTest = new PermissionTemplateDao(uuidFactory, system2, new NoOpAuditPersister()); | |||
@Before | |||
public void setUp() { |
@@ -32,6 +32,7 @@ import org.sonar.api.resources.Qualifiers; | |||
import org.sonar.api.utils.System2; | |||
import org.sonar.db.DbTester; | |||
import org.sonar.db.audit.AuditPersister; | |||
import org.sonar.db.audit.NoOpAuditPersister; | |||
import static org.assertj.core.api.Assertions.assertThat; | |||
import static org.assertj.core.api.Assertions.tuple; | |||
@@ -50,7 +51,7 @@ public class ProjectDaoTest { | |||
private final AuditPersister auditPersister = mock(AuditPersister.class); | |||
private final ProjectDao projectDao = new ProjectDao(system2); | |||
private final ProjectDao projectDao = new ProjectDao(system2, new NoOpAuditPersister()); | |||
private final ProjectDao projectDaoWithAuditPersister = new ProjectDao(system2, auditPersister); | |||
@Test | |||
@@ -201,7 +202,7 @@ public class ProjectDaoTest { | |||
projectDaoWithAuditPersister.insert(db.getSession(), dto1, true); | |||
verify(auditPersister, times(1)).addComponent(any(), any(), any()); | |||
verify(auditPersister, times(1)).addComponent(any(), any()); | |||
} | |||
@Test | |||
@@ -210,7 +211,7 @@ public class ProjectDaoTest { | |||
projectDaoWithAuditPersister.update(db.getSession(), dto1); | |||
verify(auditPersister, times(1)).updateComponent(any(), any(), any()); | |||
verify(auditPersister, times(1)).updateComponent(any(), any()); | |||
} | |||
private void assertProject(ProjectDto dto, String name, String kee, String uuid, String desc, @Nullable String tags, boolean isPrivate) { |
@@ -45,7 +45,6 @@ import static org.mockito.Mockito.mock; | |||
import static org.mockito.Mockito.times; | |||
import static org.mockito.Mockito.verify; | |||
import static org.mockito.Mockito.verifyNoInteractions; | |||
import static org.mockito.Mockito.verifyNoMoreInteractions; | |||
import static org.mockito.Mockito.when; | |||
@RunWith(DataProviderRunner.class) | |||
@@ -81,7 +80,6 @@ public class PropertiesDaoWithPersisterTest { | |||
when(auditPersister.isTrackedProperty(KEY)).thenReturn(true); | |||
underTest.saveProperty(new PropertyDto().setKey(KEY).setValue(VALUE)); | |||
verify(auditPersister).isTrackedProperty(KEY); | |||
verify(auditPersister).addProperty(any(), newValueCaptor.capture(), eq(false)); | |||
PropertyNewValue newValue = newValueCaptor.getValue(); | |||
@@ -93,23 +91,12 @@ public class PropertiesDaoWithPersisterTest { | |||
assertThat(newValue.toString()).doesNotContain("projectUuid"); | |||
} | |||
@Test | |||
public void saveGlobalNotTrackedPropertyIsNotPersisted() { | |||
when(auditPersister.isTrackedProperty(KEY)).thenReturn(false); | |||
underTest.saveProperty(new PropertyDto().setKey(KEY).setValue(VALUE)); | |||
verify(auditPersister).isTrackedProperty(KEY); | |||
verifyNoMoreInteractions(auditPersister); | |||
} | |||
@Test | |||
public void saveGlobalTrackedAndSecuredPropertyIsPersisted() { | |||
when(auditPersister.isTrackedProperty(SECURED_KEY)).thenReturn(true); | |||
underTest.saveProperty(new PropertyDto().setKey(SECURED_KEY).setValue(VALUE)); | |||
verify(auditPersister).isTrackedProperty(SECURED_KEY); | |||
verify(auditPersister).addProperty(any(), newValueCaptor.capture(), eq(false)); | |||
PropertyNewValue newValue = newValueCaptor.getValue(); | |||
assertThat(newValue) | |||
@@ -120,13 +107,12 @@ public class PropertiesDaoWithPersisterTest { | |||
} | |||
@Test | |||
public void saveProjectTrackedPropertyIsPersisted() { | |||
public void saveProjectPropertyIsPersisted() { | |||
when(auditPersister.isTrackedProperty(KEY)).thenReturn(true); | |||
PropertyDto propertyDto = getPropertyDto(KEY, PROJECT_UUID, USER_UUID); | |||
underTest.saveProperty(session, propertyDto, USER_LOGIN, PROJECT_KEY, PROJECT_NAME, Qualifiers.PROJECT); | |||
verify(auditPersister).isTrackedProperty(KEY); | |||
verify(auditPersister).addProperty(any(), newValueCaptor.capture(), eq(false)); | |||
PropertyNewValue newValue = newValueCaptor.getValue(); | |||
assertThat(newValue) | |||
@@ -135,7 +121,7 @@ public class PropertiesDaoWithPersisterTest { | |||
PropertyNewValue::getComponentUuid, PropertyNewValue::getComponentKey, | |||
PropertyNewValue::getComponentName, PropertyNewValue::getQualifier) | |||
.containsExactly(propertyDto.getKey(), propertyDto.getValue(), propertyDto.getUserUuid(), | |||
USER_LOGIN, propertyDto.getComponentUuid(), PROJECT_KEY, PROJECT_NAME, "project"); | |||
USER_LOGIN, propertyDto.getComponentUuid(), PROJECT_KEY, PROJECT_NAME, "TRK"); | |||
assertThat(newValue.toString()).contains("componentUuid"); | |||
} | |||
@@ -146,7 +132,6 @@ public class PropertiesDaoWithPersisterTest { | |||
PropertyDto propertyDto = getPropertyDto(KEY, PROJECT_UUID, USER_UUID); | |||
underTest.saveProperty(session, propertyDto, USER_LOGIN, "app-key", "app-name", Qualifiers.APP); | |||
verify(auditPersister).isTrackedProperty(KEY); | |||
verify(auditPersister).addProperty(any(), newValueCaptor.capture(), eq(false)); | |||
PropertyNewValue newValue = newValueCaptor.getValue(); | |||
assertThat(newValue) | |||
@@ -155,7 +140,7 @@ public class PropertiesDaoWithPersisterTest { | |||
PropertyNewValue::getComponentUuid, PropertyNewValue::getComponentKey, | |||
PropertyNewValue::getComponentName, PropertyNewValue::getQualifier) | |||
.containsExactly(propertyDto.getKey(), propertyDto.getValue(), propertyDto.getUserUuid(), | |||
USER_LOGIN, propertyDto.getComponentUuid(), "app-key", "app-name", "application"); | |||
USER_LOGIN, propertyDto.getComponentUuid(), "app-key", "app-name", "APP"); | |||
assertThat(newValue.toString()) | |||
.contains("componentUuid"); | |||
} | |||
@@ -167,7 +152,6 @@ public class PropertiesDaoWithPersisterTest { | |||
PropertyDto propertyDto = getPropertyDto(KEY, PROJECT_UUID, USER_UUID); | |||
underTest.saveProperty(session, propertyDto, USER_LOGIN, "portfolio-key", "portfolio-name", Qualifiers.VIEW); | |||
verify(auditPersister).isTrackedProperty(KEY); | |||
verify(auditPersister).addProperty(any(), newValueCaptor.capture(), eq(false)); | |||
PropertyNewValue newValue = newValueCaptor.getValue(); | |||
assertThat(newValue) | |||
@@ -176,7 +160,7 @@ public class PropertiesDaoWithPersisterTest { | |||
PropertyNewValue::getComponentUuid, PropertyNewValue::getComponentKey, | |||
PropertyNewValue::getComponentName, PropertyNewValue::getQualifier) | |||
.containsExactly(propertyDto.getKey(), propertyDto.getValue(), propertyDto.getUserUuid(), | |||
USER_LOGIN, propertyDto.getComponentUuid(), "portfolio-key", "portfolio-name", "portfolio"); | |||
USER_LOGIN, propertyDto.getComponentUuid(), "portfolio-key", "portfolio-name", "VW"); | |||
assertThat(newValue.toString()) | |||
.contains("componentUuid"); | |||
} | |||
@@ -188,7 +172,6 @@ public class PropertiesDaoWithPersisterTest { | |||
PropertyDto propertyDto = getPropertyDto(SECURED_KEY, PROJECT_UUID, USER_UUID); | |||
underTest.saveProperty(session, propertyDto, USER_LOGIN, PROJECT_KEY, PROJECT_NAME, Qualifiers.PROJECT); | |||
verify(auditPersister).isTrackedProperty(SECURED_KEY); | |||
verify(auditPersister).addProperty(any(), newValueCaptor.capture(), eq(false)); | |||
PropertyNewValue newValue = newValueCaptor.getValue(); | |||
assertThat(newValue) | |||
@@ -197,7 +180,7 @@ public class PropertiesDaoWithPersisterTest { | |||
PropertyNewValue::getComponentUuid, PropertyNewValue::getComponentKey, | |||
PropertyNewValue::getComponentName, PropertyNewValue::getQualifier) | |||
.containsExactly(propertyDto.getKey(), null, propertyDto.getUserUuid(), | |||
USER_LOGIN, propertyDto.getComponentUuid(), PROJECT_KEY, PROJECT_NAME, "project"); | |||
USER_LOGIN, propertyDto.getComponentUuid(), PROJECT_KEY, PROJECT_NAME, "TRK"); | |||
assertThat(newValue.toString()).contains("componentUuid"); | |||
} | |||
@@ -210,7 +193,6 @@ public class PropertiesDaoWithPersisterTest { | |||
underTest.deleteByQuery(session, query); | |||
verify(auditPersister, times(2)).isTrackedProperty(KEY); | |||
verify(auditPersister).deleteProperty(any(), newValueCaptor.capture(), eq(false)); | |||
PropertyNewValue newValue = newValueCaptor.getValue(); | |||
assertThat(newValue) | |||
@@ -232,19 +214,6 @@ public class PropertiesDaoWithPersisterTest { | |||
verifyNoInteractions(auditPersister); | |||
} | |||
@Test | |||
public void deleteNotTrackedPropertyByQueryIsNotPersisted() { | |||
when(auditPersister.isTrackedProperty(KEY)).thenReturn(false); | |||
PropertyQuery query = getPropertyQuery(KEY); | |||
PropertyDto propertyDto = getPropertyDto(KEY, PROJECT_UUID, USER_UUID); | |||
underTest.saveProperty(session, propertyDto, USER_LOGIN, PROJECT_KEY, PROJECT_NAME, Qualifiers.PROJECT); | |||
underTest.deleteByQuery(session, query); | |||
verify(auditPersister, times(2)).isTrackedProperty(KEY); | |||
verifyNoMoreInteractions(auditPersister); | |||
} | |||
@Test | |||
public void deleteTrackedPropertyIsPersisted() { | |||
when(auditPersister.isTrackedProperty(KEY)).thenReturn(true); | |||
@@ -253,7 +222,6 @@ public class PropertiesDaoWithPersisterTest { | |||
underTest.delete(session, propertyDto, USER_LOGIN, PROJECT_KEY, PROJECT_NAME, Qualifiers.PROJECT); | |||
verify(auditPersister, times(2)).isTrackedProperty(KEY); | |||
verify(auditPersister).deleteProperty(any(), newValueCaptor.capture(), eq(false)); | |||
PropertyNewValue newValue = newValueCaptor.getValue(); | |||
assertThat(newValue) | |||
@@ -275,18 +243,6 @@ public class PropertiesDaoWithPersisterTest { | |||
verifyNoInteractions(auditPersister); | |||
} | |||
@Test | |||
public void deleteNotTrackedPropertyIsNotPersisted() { | |||
when(auditPersister.isTrackedProperty(KEY)).thenReturn(false); | |||
PropertyDto propertyDto = getPropertyDto(KEY, PROJECT_UUID, USER_UUID); | |||
underTest.saveProperty(session, propertyDto, USER_LOGIN, PROJECT_KEY, PROJECT_NAME, Qualifiers.PROJECT); | |||
underTest.delete(session, propertyDto, USER_LOGIN, PROJECT_KEY, PROJECT_NAME, Qualifiers.PROJECT); | |||
verify(auditPersister, times(2)).isTrackedProperty(KEY); | |||
verifyNoMoreInteractions(auditPersister); | |||
} | |||
@Test | |||
public void deleteTrackedProjectPropertyIsPersisted() { | |||
when(auditPersister.isTrackedProperty(KEY)).thenReturn(true); | |||
@@ -295,7 +251,6 @@ public class PropertiesDaoWithPersisterTest { | |||
underTest.deleteProjectProperty(KEY, PROJECT_UUID, PROJECT_KEY, PROJECT_NAME, Qualifiers.PROJECT); | |||
verify(auditPersister, times(2)).isTrackedProperty(KEY); | |||
verify(auditPersister).deleteProperty(any(), newValueCaptor.capture(), eq(false)); | |||
PropertyNewValue newValue = newValueCaptor.getValue(); | |||
assertThat(newValue) | |||
@@ -315,18 +270,6 @@ public class PropertiesDaoWithPersisterTest { | |||
verifyNoInteractions(auditPersister); | |||
} | |||
@Test | |||
public void deleteNotTrackedProjectPropertyIsNotPersisted() { | |||
when(auditPersister.isTrackedProperty(KEY)).thenReturn(false); | |||
PropertyDto propertyDto = getPropertyDto(KEY, PROJECT_UUID, USER_UUID); | |||
underTest.saveProperty(session, propertyDto, USER_LOGIN, PROJECT_KEY, PROJECT_NAME, Qualifiers.PROJECT); | |||
underTest.delete(session, propertyDto, USER_LOGIN, PROJECT_KEY, PROJECT_NAME, Qualifiers.PROJECT); | |||
verify(auditPersister, times(2)).isTrackedProperty(KEY); | |||
verifyNoMoreInteractions(auditPersister); | |||
} | |||
@Test | |||
public void deleteTrackedProjectPropertiesIsPersisted() { | |||
when(auditPersister.isTrackedProperty(KEY)).thenReturn(true); | |||
@@ -335,7 +278,6 @@ public class PropertiesDaoWithPersisterTest { | |||
underTest.deleteProjectProperties(KEY, VALUE); | |||
verify(auditPersister, times(2)).isTrackedProperty(KEY); | |||
verify(auditPersister).deleteProperty(any(), newValueCaptor.capture(), eq(false)); | |||
PropertyNewValue newValue = newValueCaptor.getValue(); | |||
assertThat(newValue) | |||
@@ -355,18 +297,6 @@ public class PropertiesDaoWithPersisterTest { | |||
verifyNoInteractions(auditPersister); | |||
} | |||
@Test | |||
public void deleteNotTrackedProjectPropertiesIsNotPersisted() { | |||
when(auditPersister.isTrackedProperty(KEY)).thenReturn(false); | |||
PropertyDto propertyDto = getPropertyDto(KEY, PROJECT_UUID, null); | |||
underTest.saveProperty(propertyDto); | |||
underTest.deleteProjectProperties(KEY, VALUE); | |||
verify(auditPersister, times(2)).isTrackedProperty(KEY); | |||
verifyNoMoreInteractions(auditPersister); | |||
} | |||
@Test | |||
public void deleteTrackedGlobalPropertyIsPersisted() { | |||
when(auditPersister.isTrackedProperty(KEY)).thenReturn(true); | |||
@@ -375,7 +305,6 @@ public class PropertiesDaoWithPersisterTest { | |||
underTest.deleteGlobalProperty(KEY, session); | |||
verify(auditPersister, times(2)).isTrackedProperty(KEY); | |||
verify(auditPersister).deleteProperty(any(), newValueCaptor.capture(), eq(false)); | |||
PropertyNewValue newValue = newValueCaptor.getValue(); | |||
assertThat(newValue) | |||
@@ -395,26 +324,11 @@ public class PropertiesDaoWithPersisterTest { | |||
verifyNoInteractions(auditPersister); | |||
} | |||
@Test | |||
public void deleteNotTrackedGlobalPropertyIsNotPersisted() { | |||
when(auditPersister.isTrackedProperty(KEY)).thenReturn(false); | |||
PropertyDto propertyDto = getPropertyDto(KEY, null, null); | |||
underTest.saveProperty(session, propertyDto, null, null, null, null); | |||
underTest.deleteGlobalProperty(KEY, session); | |||
verify(auditPersister, times(2)).isTrackedProperty(KEY); | |||
verifyNoMoreInteractions(auditPersister); | |||
} | |||
@Test | |||
public void deletePropertyByUserIsPersisted() { | |||
UserDto user = setUserProperties(VALUE); | |||
underTest.deleteByUser(session, user.getUuid(), user.getLogin()); | |||
verify(auditPersister, times(2)).isTrackedProperty(KEY); | |||
verify(auditPersister, times(2)).isTrackedProperty(ANOTHER_KEY); | |||
verify(auditPersister, times(2)).isTrackedProperty(SECURED_KEY); | |||
verify(auditPersister, times(2)).deleteProperty(any(), newValueCaptor.capture(), eq(false)); | |||
List<PropertyNewValue> newValues = newValueCaptor.getAllValues(); | |||
assertThat(newValues.get(0)) | |||
@@ -446,9 +360,6 @@ public class PropertiesDaoWithPersisterTest { | |||
UserDto user = setUserProperties(null); | |||
underTest.deleteByMatchingLogin(session, user.getLogin(), newArrayList(KEY, ANOTHER_KEY, SECURED_KEY)); | |||
verify(auditPersister, times(2)).isTrackedProperty(KEY); | |||
verify(auditPersister, times(2)).isTrackedProperty(ANOTHER_KEY); | |||
verify(auditPersister, times(2)).isTrackedProperty(SECURED_KEY); | |||
verify(auditPersister, times(2)).deleteProperty(any(), newValueCaptor.capture(), eq(false)); | |||
List<PropertyNewValue> newValues = newValueCaptor.getAllValues(); | |||
assertThat(newValues.get(0)) | |||
@@ -484,7 +395,6 @@ public class PropertiesDaoWithPersisterTest { | |||
underTest.saveProperty(session, propertyDto, USER_LOGIN, null, null, null); | |||
underTest.deleteByKeyAndValue(session, KEY, VALUE); | |||
verify(auditPersister, times(2)).isTrackedProperty(KEY); | |||
verify(auditPersister).deleteProperty(any(), newValueCaptor.capture(), eq(false)); | |||
PropertyNewValue newValue = newValueCaptor.getValue(); | |||
assertThat(newValue) | |||
@@ -504,18 +414,6 @@ public class PropertiesDaoWithPersisterTest { | |||
verifyNoInteractions(auditPersister); | |||
} | |||
@Test | |||
public void deleteNotTrackedPropertyByKeyAndValueIsNotPersisted() { | |||
when(auditPersister.isTrackedProperty(KEY)).thenReturn(false); | |||
PropertyDto propertyDto = getPropertyDto(KEY, null, USER_UUID); | |||
underTest.saveProperty(session, propertyDto, USER_LOGIN, null, null, null); | |||
underTest.deleteByKeyAndValue(session, KEY, VALUE); | |||
verify(auditPersister, times(2)).isTrackedProperty(KEY); | |||
verifyNoMoreInteractions(auditPersister); | |||
} | |||
private PropertyDto getPropertyDto(String key, @Nullable String projectUuid, @Nullable String userUuid) { | |||
return new PropertyDto() | |||
.setKey(key) |
@@ -59,12 +59,11 @@ public class PurgeDaoWithAuditTest { | |||
underTestWithPersister.deleteProject(dbSession, project.uuid(), project.qualifier(), project.name(), project.getKey()); | |||
verify(auditPersister).deleteComponent(any(DbSession.class), newValueCaptor.capture(), eq(project.qualifier())); | |||
verify(auditPersister).deleteComponent(any(DbSession.class), newValueCaptor.capture()); | |||
ComponentNewValue componentNewValue = newValueCaptor.getValue(); | |||
assertThat(componentNewValue) | |||
.extracting(ComponentNewValue::getComponentUuid, ComponentNewValue::getComponentName, ComponentNewValue::getComponentKey, | |||
ComponentNewValue::getQualifier) | |||
.containsExactly(project.uuid(), project.name(), project.getKey(), "project"); | |||
.extracting(ComponentNewValue::getComponentUuid, ComponentNewValue::getComponentName, ComponentNewValue::getComponentKey, ComponentNewValue::getQualifier) | |||
.containsExactly(project.uuid(), project.name(), project.getKey(), "TRK"); | |||
} | |||
} |
@@ -92,7 +92,8 @@ public class UserGroupDaoWithPersisterTest { | |||
underTest.deleteByGroupUuid(db.getSession(), group1.getUuid(), group1.getName()); | |||
db.getSession().commit(); | |||
verifyNoInteractions(auditPersister); | |||
verify(auditPersister).addUserGroup(any(), any()); | |||
verifyNoMoreInteractions(auditPersister); | |||
} | |||
@Test | |||
@@ -145,13 +146,14 @@ public class UserGroupDaoWithPersisterTest { | |||
} | |||
@Test | |||
public void deletByUserAndGroupWithoutAffectedRowsIsNotPersisted() { | |||
public void deleteByUserAndGroupWithoutAffectedRowsIsNotPersisted() { | |||
UserDto user1 = db.users().insertUser(); | |||
GroupDto group1 = db.users().insertGroup(); | |||
underTest.delete(db.getSession(), group1, user1); | |||
db.getSession().commit(); | |||
verify(auditPersister).addUser(any(), any()); | |||
verify(auditPersister).addUserGroup(any(), any()); | |||
verifyNoMoreInteractions(auditPersister); | |||
} | |||
} |
@@ -53,8 +53,6 @@ public class UserPropertiesDaoWithPersisterTest { | |||
@Test | |||
public void insertTrackedUserPropertyIsPersisted() { | |||
when(auditPersister.isTrackedProperty(PROPERTY_KEY)).thenReturn(true); | |||
UserDto user = db.users().insertUser(); | |||
verify(auditPersister).addUser(eq(db.getSession()), any()); | |||
@@ -66,7 +64,6 @@ public class UserPropertiesDaoWithPersisterTest { | |||
user.getLogin()); | |||
verify(auditPersister).addProperty(eq(db.getSession()), newValueCaptor.capture(), eq(true)); | |||
verify(auditPersister).isTrackedProperty(PROPERTY_KEY); | |||
assertThat(newValueCaptor.getValue()) | |||
.extracting(PropertyNewValue::getPropertyKey, PropertyNewValue::getPropertyValue, PropertyNewValue::getUserUuid, | |||
PropertyNewValue::getUserLogin) | |||
@@ -76,8 +73,6 @@ public class UserPropertiesDaoWithPersisterTest { | |||
@Test | |||
public void insertTrackedAndSecuredUserPropertyIsPersisted() { | |||
when(auditPersister.isTrackedProperty(SECURED_PROPERTY_KEY)).thenReturn(true); | |||
UserDto user = db.users().insertUser(); | |||
verify(auditPersister).addUser(eq(db.getSession()), any()); | |||
@@ -88,7 +83,6 @@ public class UserPropertiesDaoWithPersisterTest { | |||
.setValue("a_value"), | |||
user.getLogin()); | |||
verify(auditPersister).isTrackedProperty(SECURED_PROPERTY_KEY); | |||
verify(auditPersister).addProperty(eq(db.getSession()), newValueCaptor.capture(), eq(true)); | |||
PropertyNewValue newValue = newValueCaptor.getValue(); | |||
assertThat(newValue) | |||
@@ -98,26 +92,8 @@ public class UserPropertiesDaoWithPersisterTest { | |||
assertThat(newValue.toString()).doesNotContain("propertyValue"); | |||
} | |||
@Test | |||
public void insertNotTrackedUserPropertyIsNotPersisted() { | |||
when(auditPersister.isTrackedProperty(PROPERTY_KEY)).thenReturn(false); | |||
UserDto user = db.users().insertUser(); | |||
underTest.insertOrUpdate(db.getSession(), new UserPropertyDto() | |||
.setUserUuid(user.getUuid()) | |||
.setKey(PROPERTY_KEY) | |||
.setValue("a_value"), | |||
user.getLogin()); | |||
verify(auditPersister).addUser(eq(db.getSession()), any()); | |||
verify(auditPersister).isTrackedProperty(PROPERTY_KEY); | |||
verifyNoMoreInteractions(auditPersister); | |||
} | |||
@Test | |||
public void updateTrackedUserPropertyIsPersisted() { | |||
when(auditPersister.isTrackedProperty(PROPERTY_KEY)).thenReturn(true); | |||
UserDto user = db.users().insertUser(); | |||
underTest.insertOrUpdate(db.getSession(), new UserPropertyDto() | |||
.setUserUuid(user.getUuid()) | |||
@@ -159,10 +135,9 @@ public class UserPropertiesDaoWithPersisterTest { | |||
underTest.deleteByUser(db.getSession(), user); | |||
verify(auditPersister).addUser(eq(db.getSession()), any()); | |||
verify(auditPersister).addProperty(eq(db.getSession()), any(), eq(true)); | |||
verify(auditPersister).addProperty(eq(db.getSession()), any(), eq(true)); | |||
verify(auditPersister, times(2)).isTrackedProperty(PROPERTY_KEY); | |||
verify(auditPersister, times(2)).isTrackedProperty(SECURED_PROPERTY_KEY); | |||
verify(auditPersister, times(2)).addProperty(eq(db.getSession()), any(), eq(true)); | |||
verify(auditPersister).isTrackedProperty(PROPERTY_KEY); | |||
verify(auditPersister).isTrackedProperty(SECURED_PROPERTY_KEY); | |||
verify(auditPersister).deleteProperty(eq(db.getSession()), newValueCaptor.capture(), eq(true)); | |||
verifyNoMoreInteractions(auditPersister); | |||
assertThat(newValueCaptor.getValue()) |
@@ -63,7 +63,7 @@ public class UserTokenDaoTest { | |||
UserTokenDto userToken2 = db.users().insertToken(user1); | |||
assertThat(underTest.selectByTokenHash(dbSession, userToken1.getTokenHash()).getLastConnectionDate()).isNull(); | |||
underTest.update(dbSession, userToken1.setLastConnectionDate(10_000_000_000L), false, null); | |||
underTest.updateWithoutAudit(dbSession, userToken1.setLastConnectionDate(10_000_000_000L)); | |||
UserTokenDto userTokenReloaded = underTest.selectByTokenHash(dbSession, userToken1.getTokenHash()); | |||
assertThat(userTokenReloaded.getLastConnectionDate()).isEqualTo(10_000_000_000L); |
@@ -78,7 +78,7 @@ public class UserTokenDaoWithPersisterTest { | |||
assertThat(underTest.selectByTokenHash(dbSession, userToken1.getTokenHash()).getLastConnectionDate()).isNull(); | |||
underTest.update(dbSession, userToken1.setLastConnectionDate(10_000_000_000L), false, null); | |||
underTest.updateWithoutAudit(dbSession, userToken1.setLastConnectionDate(10_000_000_000L)); | |||
underTest.update(dbSession, userToken1.setName("new_name"), user1.getLogin()); | |||
verify(auditPersister).updateUserToken(eq(db.getSession()), newValueCaptor.capture()); |
@@ -37,7 +37,6 @@ import static org.mockito.ArgumentMatchers.any; | |||
import static org.mockito.ArgumentMatchers.eq; | |||
import static org.mockito.Mockito.mock; | |||
import static org.mockito.Mockito.never; | |||
import static org.mockito.Mockito.times; | |||
import static org.mockito.Mockito.verify; | |||
import static org.mockito.Mockito.verifyNoMoreInteractions; | |||
@@ -180,7 +179,7 @@ public class WebhookDaoWithPersisterTest { | |||
underTest.deleteByProject(dbSession, projectDto); | |||
verify(auditPersister).addComponent(any(), any(), any()); | |||
verify(auditPersister).addComponent(any(), any()); | |||
verifyNoMoreInteractions(auditPersister); | |||
} | |||
@@ -36,6 +36,7 @@ import org.sonar.db.alm.integration.pat.AlmPatsDbTester; | |||
import org.sonar.db.almsettings.AlmSettingsDbTester; | |||
import org.sonar.db.audit.AuditDbTester; | |||
import org.sonar.db.audit.AuditPersister; | |||
import org.sonar.db.audit.NoOpAuditPersister; | |||
import org.sonar.db.component.ComponentDbTester; | |||
import org.sonar.db.component.ProjectLinkDbTester; | |||
import org.sonar.db.event.EventDbTester; | |||
@@ -65,6 +66,7 @@ public class DbTester extends AbstractDbTester<TestDbImpl> { | |||
private final UuidFactory uuidFactory = new SequenceUuidFactory(); | |||
private final System2 system2; | |||
private final AuditPersister auditPersister; | |||
private DbClient client; | |||
private DbSession session = null; | |||
private final UserDbTester userTester; | |||
@@ -94,8 +96,9 @@ public class DbTester extends AbstractDbTester<TestDbImpl> { | |||
private DbTester(System2 system2, @Nullable String schemaPath, AuditPersister auditPersister, MyBatisConfExtension... confExtensions) { | |||
super(TestDbImpl.create(schemaPath, confExtensions)); | |||
this.system2 = system2; | |||
this.auditPersister = auditPersister; | |||
initDbClient(auditPersister); | |||
initDbClient(); | |||
this.userTester = new UserDbTester(this); | |||
this.componentTester = new ComponentDbTester(this); | |||
this.componentLinkTester = new ProjectLinkDbTester(this); | |||
@@ -122,7 +125,7 @@ public class DbTester extends AbstractDbTester<TestDbImpl> { | |||
} | |||
public static DbTester create() { | |||
return new DbTester(System2.INSTANCE, null, null); | |||
return new DbTester(System2.INSTANCE, null, new NoOpAuditPersister()); | |||
} | |||
public static DbTester create(AuditPersister auditPersister) { | |||
@@ -134,18 +137,16 @@ public class DbTester extends AbstractDbTester<TestDbImpl> { | |||
} | |||
public static DbTester create(System2 system2) { | |||
return new DbTester(system2, null, null); | |||
return new DbTester(system2, null, new NoOpAuditPersister()); | |||
} | |||
public static DbTester createWithExtensionMappers(System2 system2, Class<?> firstMapperClass, Class<?>... otherMapperClasses) { | |||
return new DbTester(system2, null, null, new DbTesterMyBatisConfExtension(firstMapperClass, otherMapperClasses)); | |||
return new DbTester(system2, null, new NoOpAuditPersister(), new DbTesterMyBatisConfExtension(firstMapperClass, otherMapperClasses)); | |||
} | |||
private void initDbClient(AuditPersister auditPersister) { | |||
private void initDbClient() { | |||
TransientPicoContainer ioc = new TransientPicoContainer(); | |||
if (auditPersister != null) { | |||
ioc.addComponent(auditPersister); | |||
} | |||
ioc.addComponent(auditPersister); | |||
ioc.addComponent(db.getMyBatis()); | |||
ioc.addComponent(system2); | |||
ioc.addComponent(uuidFactory); | |||
@@ -160,7 +161,7 @@ public class DbTester extends AbstractDbTester<TestDbImpl> { | |||
protected void before() { | |||
db.start(); | |||
db.truncateTables(); | |||
initDbClient(null); | |||
initDbClient(); | |||
} | |||
public UserDbTester users() { |
@@ -194,6 +194,7 @@ public class ComponentTesting { | |||
return new ComponentDto() | |||
.setUuid(uuid) | |||
.setUuidPath(formatUuidPathFromParent(parent)) | |||
.setDbKey(uuid) | |||
.setProjectUuid(moduleOrProject.projectUuid()) | |||
.setRootUuid(moduleOrProject.uuid()) | |||
.setModuleUuid(moduleOrProject.uuid()) |
@@ -59,7 +59,7 @@ public class UserLastConnectionDatesUpdaterImpl implements UserLastConnectionDat | |||
return; | |||
} | |||
try (DbSession dbSession = dbClient.openSession(false)) { | |||
dbClient.userTokenDao().update(dbSession, userToken.setLastConnectionDate(now), false, null); | |||
dbClient.userTokenDao().updateWithoutAudit(dbSession, userToken.setLastConnectionDate(now)); | |||
userToken.setLastConnectionDate(now); | |||
dbSession.commit(); | |||
} |
@@ -21,8 +21,8 @@ package org.sonar.server.authentication; | |||
import org.junit.Rule; | |||
import org.junit.Test; | |||
import org.sonar.api.utils.System2; | |||
import org.sonar.api.impl.utils.TestSystem2; | |||
import org.sonar.api.utils.System2; | |||
import org.sonar.db.DbTester; | |||
import org.sonar.db.user.UserDto; | |||
import org.sonar.db.user.UserTokenDto; | |||
@@ -79,7 +79,7 @@ public class UserLastConnectionDatesUpdaterImplTest { | |||
public void update_last_connection_date_from_user_token_when_last_connection_was_more_than_one_hour() { | |||
UserDto user = db.users().insertUser(); | |||
UserTokenDto userToken = db.users().insertToken(user); | |||
db.getDbClient().userTokenDao().update(db.getSession(), userToken.setLastConnectionDate(NOW - TWO_HOUR), false, null); | |||
db.getDbClient().userTokenDao().updateWithoutAudit(db.getSession(), userToken.setLastConnectionDate(NOW - TWO_HOUR)); | |||
db.commit(); | |||
underTest.updateLastConnectionDateIfNeeded(userToken); | |||
@@ -103,7 +103,7 @@ public class UserLastConnectionDatesUpdaterImplTest { | |||
public void do_not_update_when_last_connection_from_user_token_was_less_than_one_hour() { | |||
UserDto user = db.users().insertUser(); | |||
UserTokenDto userToken = db.users().insertToken(user); | |||
db.getDbClient().userTokenDao().update(db.getSession(), userToken.setLastConnectionDate(NOW - ONE_MINUTE), false, null); | |||
db.getDbClient().userTokenDao().updateWithoutAudit(db.getSession(), userToken.setLastConnectionDate(NOW - ONE_MINUTE)); | |||
db.commit(); | |||
underTest.updateLastConnectionDateIfNeeded(userToken); |
@@ -26,8 +26,6 @@ import org.sonar.api.resources.Qualifiers; | |||
import org.sonar.api.server.ws.Request; | |||
import org.sonar.api.server.ws.Response; | |||
import org.sonar.api.server.ws.WebService; | |||
import org.sonar.api.utils.log.Logger; | |||
import org.sonar.api.utils.log.Loggers; | |||
import org.sonar.core.util.UuidFactory; | |||
import org.sonar.core.util.Uuids; | |||
import org.sonar.db.DbClient; | |||
@@ -135,8 +133,7 @@ public class UpdateVisibilityAction implements ProjectsWsAction { | |||
private void setPrivateForRootComponentUuid(DbSession dbSession, ComponentDto component, boolean isPrivate) { | |||
String uuid = component.uuid(); | |||
dbClient.componentDao().setPrivateForRootComponentUuid(dbSession, uuid, isPrivate, component.getKey(), | |||
component.qualifier(), component.name(), true); | |||
dbClient.componentDao().setPrivateForRootComponentUuid(dbSession, uuid, isPrivate, component.getKey(), component.qualifier(), component.name()); | |||
if (component.qualifier().equals(Qualifiers.PROJECT) || component.qualifier().equals(Qualifiers.APP)) { | |||
dbClient.projectDao().updateVisibility(dbSession, uuid, isPrivate); | |||
@@ -165,7 +162,6 @@ public class UpdateVisibilityAction implements ProjectsWsAction { | |||
}); | |||
} | |||
private void insertProjectPermissionOnUser(DbSession dbSession, ComponentDto component, String permission, UserId userId) { | |||
dbClient.userPermissionDao().insert(dbSession, new UserPermissionDto(Uuids.create(), permission, userId.getUuid(), component.uuid()), | |||
component, userId, null); |
@@ -35,13 +35,7 @@ public class GenerateSecretKeyAction implements SettingsWsAction { | |||
private final DbClient dbClient; | |||
private final Settings settings; | |||
private final UserSession userSession; | |||
private AuditPersister auditPersister; | |||
public GenerateSecretKeyAction(DbClient dbClient, Settings settings, UserSession userSession) { | |||
this.dbClient = dbClient; | |||
this.settings = settings; | |||
this.userSession = userSession; | |||
} | |||
private final AuditPersister auditPersister; | |||
public GenerateSecretKeyAction(DbClient dbClient, Settings settings, UserSession userSession, AuditPersister auditPersister) { | |||
this.dbClient = dbClient; | |||
@@ -67,11 +61,9 @@ public class GenerateSecretKeyAction implements SettingsWsAction { | |||
writeProtobuf(GenerateSecretKeyWsResponse.newBuilder().setSecretKey(settings.getEncryption().generateRandomSecretKey()).build(), request, response); | |||
if (auditPersister != null) { | |||
try (DbSession dbSession = dbClient.openSession(false)) { | |||
auditPersister.generateSecretKey(dbSession); | |||
dbSession.commit(); | |||
} | |||
try (DbSession dbSession = dbClient.openSession(false)) { | |||
auditPersister.generateSecretKey(dbSession); | |||
dbSession.commit(); | |||
} | |||
} | |||
} |
@@ -33,6 +33,7 @@ import org.sonar.api.server.ws.WebService; | |||
import org.sonar.api.utils.System2; | |||
import org.sonar.db.DbClient; | |||
import org.sonar.db.DbTester; | |||
import org.sonar.db.audit.NoOpAuditPersister; | |||
import org.sonar.server.exceptions.ForbiddenException; | |||
import org.sonar.server.tester.UserSessionRule; | |||
import org.sonar.server.ws.WsActionTester; | |||
@@ -53,7 +54,7 @@ public class GenerateSecretKeyActionTest { | |||
private DbClient dbClient = db.getDbClient(); | |||
private MapSettings settings = new MapSettings(); | |||
private Encryption encryption = settings.getEncryption(); | |||
private GenerateSecretKeyAction underTest = new GenerateSecretKeyAction(dbClient, settings, userSession); | |||
private GenerateSecretKeyAction underTest = new GenerateSecretKeyAction(dbClient, settings, userSession, new NoOpAuditPersister()); | |||
private WsActionTester ws = new WsActionTester(underTest); | |||
@Test |
@@ -28,6 +28,7 @@ import org.sonar.api.utils.System2; | |||
import org.sonar.api.web.UserRole; | |||
import org.sonar.core.util.Uuids; | |||
import org.sonar.db.DbTester; | |||
import org.sonar.db.audit.NoOpAuditPersister; | |||
import org.sonar.db.component.ComponentDao; | |||
import org.sonar.db.component.ComponentDto; | |||
import org.sonar.db.component.SnapshotDao; | |||
@@ -62,7 +63,7 @@ public class LinesActionTest { | |||
@Rule | |||
public UserSessionRule userSession = UserSessionRule.standalone(); | |||
private final ComponentDao componentDao = new ComponentDao(); | |||
private final ComponentDao componentDao = new ComponentDao(new NoOpAuditPersister()); | |||
private final SnapshotDao snapshotDao = new SnapshotDao(); | |||
private final HtmlSourceDecorator htmlSourceDecorator = mock(HtmlSourceDecorator.class); | |||
private final SourceService sourceService = new SourceService(db.getDbClient(), htmlSourceDecorator); |
@@ -100,7 +100,7 @@ public class SearchActionTest { | |||
UserDto user = db.users().insertUser(); | |||
UserTokenDto token1 = db.users().insertToken(user); | |||
UserTokenDto token2 = db.users().insertToken(user); | |||
db.getDbClient().userTokenDao().update(db.getSession(), token1.setLastConnectionDate(10_000_000_000L), false, user.getLogin()); | |||
db.getDbClient().userTokenDao().updateWithoutAudit(db.getSession(), token1.setLastConnectionDate(10_000_000_000L)); | |||
db.commit(); | |||
logInAsSystemAdministrator(); | |||
@@ -29,6 +29,8 @@ import org.sonar.api.internal.MetadataLoader; | |||
import org.sonar.api.internal.SonarRuntimeImpl; | |||
import org.sonar.api.utils.System2; | |||
import org.sonar.api.utils.Version; | |||
import org.sonar.db.audit.AuditPersister; | |||
import org.sonar.db.audit.NoOpAuditPersister; | |||
import org.sonar.server.issue.index.IssueIndexSyncProgressChecker; | |||
import org.sonar.server.platform.DockerSupportImpl; | |||
import org.sonar.server.util.GlobalLockManagerImpl; | |||
@@ -162,6 +164,9 @@ public class PlatformLevel1 extends PlatformLevel { | |||
.load(); | |||
get(WebCoreExtensionsInstaller.class) | |||
.install(getContainer(), hasPlatformLevel(1), noAdditionalSideFilter()); | |||
if (getOptional(AuditPersister.class).isEmpty()) { | |||
add(NoOpAuditPersister.class); | |||
} | |||
return super.start(); | |||
} |