public HttpResponseMessage RemoveSensitivityLevel(int id, [FromBody] SensitiveDataLevel dataSensitivityLevel)
{
var result = _usageService.RemoveSensitiveDataLevel(id, dataSensitivityLevel);
return(result.Match
(
onSuccess: itSystemUsageDataLevel => Ok(MapSensitiveDataLevelDTO(itSystemUsageDataLevel)),
onFailure: FromOperationError
));
}
public static string GetReadableName(this SensitiveDataLevel sensitiveDataLevel)
{
return(sensitiveDataLevel switch
{
SensitiveDataLevel.NONE => "Ingen persondata",
SensitiveDataLevel.PERSONALDATA => "Almindelige persondata",
SensitiveDataLevel.SENSITIVEDATA => "Følsomme persondata",
SensitiveDataLevel.LEGALDATA => "Straffedomme og lovovertrædelser",
_ => throw new InvalidOperationException($"Invalid sensitiveDataLevel value: {sensitiveDataLevel}"),
});
public void AddSensitiveData_Returns_Ok(SensitiveDataLevel sensitiveDataLevel)
{
//Act
var result = _sut.AddSensitiveDataLevel(sensitiveDataLevel);
//Assert
Assert.True(result.Ok);
var usageSensitiveDataLevel = result.Value;
Assert.Equal(sensitiveDataLevel, usageSensitiveDataLevel.SensitivityDataLevel);
Assert.Single(_sut.SensitiveDataLevels);
}
public Result <ItSystemUsageSensitiveDataLevel, OperationError> RemoveSensitiveDataLevel(
SensitiveDataLevel sensitiveDataLevel)
{
if (!SensitiveDataLevelExists(sensitiveDataLevel))
{
return(new OperationError("Data sensitivity does not exists on system usage", OperationFailure.NotFound));
}
var dataLevelToRemove = SensitiveDataLevels.First(x => x.SensitivityDataLevel == sensitiveDataLevel);
SensitiveDataLevels.Remove(dataLevelToRemove);
return(dataLevelToRemove);
}
public Result <ItSystemUsageSensitiveDataLevel, OperationError> AddSensitiveDataLevel(
SensitiveDataLevel sensitiveDataLevel)
{
if (SensitiveDataLevelExists(sensitiveDataLevel))
{
return(new OperationError("Data sensitivity level already exists", OperationFailure.Conflict));
}
var newDataLevel = new ItSystemUsageSensitiveDataLevel()
{
ItSystemUsage = this,
SensitivityDataLevel = sensitiveDataLevel
};
SensitiveDataLevels.Add(newDataLevel);
return(newDataLevel);
}
public void AddSensitiveData_Returns_Ok(SensitiveDataLevel sensitiveDataLevel)
{
//Arrange
var itSystem = CreateItSystem();
var itSystemUsage = CreateSystemUsage(A <int>(), itSystem);
ExpectAllowModifyReturns(itSystemUsage, true);
_usageRepository.Setup(x => x.GetByKey(itSystemUsage.Id)).Returns(itSystemUsage);
//Act
var result = _sut.AddSensitiveDataLevel(itSystemUsage.Id, sensitiveDataLevel);
//Assert
Assert.True(result.Ok);
var addedSensitiveData = result.Value;
Assert.Equal(sensitiveDataLevel, addedSensitiveData.SensitivityDataLevel);
}
public void RemoveSensitiveData_Returns_Ok(SensitiveDataLevel sensitiveDataLevel)
{
//Arrange
var preAddedSensitiveDataLevel = new ItSystemUsageSensitiveDataLevel()
{
ItSystemUsage = _sut,
SensitivityDataLevel = sensitiveDataLevel
};
_sut.SensitiveDataLevels.Add(preAddedSensitiveDataLevel);
//Act
var result = _sut.RemoveSensitiveDataLevel(sensitiveDataLevel);
//Assert
Assert.True(result.Ok);
var usageSensitiveDataLevel = result.Value;
Assert.Equal(preAddedSensitiveDataLevel, usageSensitiveDataLevel);
Assert.Empty(_sut.SensitiveDataLevels);
}
private void AssertSensitiveDataLevel(SensitiveDataLevel expected, GdprExportReportCsvFormat actual)
{
switch (expected)
{
case SensitiveDataLevel.NONE:
AssertYes(actual.NoData);
AssertNo(actual.PersonalData);
AssertNo(actual.SensitiveData);
AssertNo(actual.LegalData);
return;
case SensitiveDataLevel.PERSONALDATA:
AssertNo(actual.NoData);
AssertYes(actual.PersonalData);
AssertNo(actual.SensitiveData);
AssertNo(actual.LegalData);
return;
case SensitiveDataLevel.SENSITIVEDATA:
AssertNo(actual.NoData);
AssertNo(actual.PersonalData);
AssertYes(actual.SensitiveData);
AssertNo(actual.LegalData);
return;
case SensitiveDataLevel.LEGALDATA:
AssertNo(actual.NoData);
AssertNo(actual.PersonalData);
AssertNo(actual.SensitiveData);
AssertYes(actual.LegalData);
return;
default:
throw new AssertActualExpectedException(expected, actual, "Expected is not a correct SensitiveDataLevel");
}
}
private bool SensitiveDataLevelExists(SensitiveDataLevel sensitiveDataLevel)
{
return(SensitiveDataLevels.Any(x => x.SensitivityDataLevel == sensitiveDataLevel));
}
public Result <ItSystemUsageSensitiveDataLevel, OperationError> RemoveSensitiveDataLevel(int itSystemUsageId, SensitiveDataLevel sensitiveDataLevel)
{
Maybe <ItSystemUsage> usageResult = _usageRepository.GetByKey(itSystemUsageId);
if (usageResult.IsNone)
{
return(new OperationError(OperationFailure.NotFound));
}
var usage = usageResult.Value;
if (!_authorizationContext.AllowModify(usage))
{
return(new OperationError(OperationFailure.Forbidden));
}
return(usage
.RemoveSensitiveDataLevel(sensitiveDataLevel)
.Match <Result <ItSystemUsageSensitiveDataLevel, OperationError> >
(
onSuccess: removedSensitivityLevel =>
{
_sensitiveDataLevelRepository.DeleteWithReferencePreload(removedSensitivityLevel);
_sensitiveDataLevelRepository.Save();
_usageRepository.Save();
_domainEvents.Raise(new EntityUpdatedEvent <ItSystemUsage>(usage));
return removedSensitivityLevel;
},
onFailure: error =>
error.FailureType == OperationFailure.NotFound
? new OperationError(OperationFailure.BadInput)
: error));
}
public Result <ItSystemUsageSensitiveDataLevel, OperationError> AddSensitiveDataLevel(int itSystemUsageId, SensitiveDataLevel sensitiveDataLevel)
{
Maybe <ItSystemUsage> usageResult = _usageRepository.GetByKey(itSystemUsageId);
if (usageResult.IsNone)
{
return(new OperationError(OperationFailure.NotFound));
}
var usage = usageResult.Value;
if (!_authorizationContext.AllowModify(usage))
{
return(new OperationError(OperationFailure.Forbidden));
}
return(usage
.AddSensitiveDataLevel(sensitiveDataLevel)
.Match <Result <ItSystemUsageSensitiveDataLevel, OperationError> >
(
onSuccess: addedSensitivityLevel =>
{
_usageRepository.Save();
_domainEvents.Raise(new EntityUpdatedEvent <ItSystemUsage>(usage));
return addedSensitivityLevel;
},
onFailure: error => error));
}
public static async Task <ItSystemUsageSensitiveDataLevelDTO> RemoveSensitiveDataLevel(int systemUsageId, SensitiveDataLevel sensitiveDataLevel)
{
var cookie = await HttpApi.GetCookieAsync(OrganizationRole.GlobalAdmin);
using (var okResponse = await HttpApi.PatchWithCookieAsync(TestEnvironment.CreateUrl($"api/v1/itsystemusage/{systemUsageId}/sensitivityLevel/remove"), cookie, sensitiveDataLevel))
{
Assert.Equal(HttpStatusCode.OK, okResponse.StatusCode);
return(await okResponse.ReadResponseBodyAsKitosApiResponseAsync <ItSystemUsageSensitiveDataLevelDTO>());
}
}
