public async Task <ContractExecutionResult> DeleteUserPreference(
string preferencekeyname, Guid?preferencekeyuid = null, Guid?userGuid = null)
{
var methodName = $"{nameof(DeleteUserPreference)}";
Logger.LogInformation($"{methodName} userGuid: {userGuid}, preferencekeyname: {preferencekeyname}, preferencekeyuid: {preferencekeyuid}");
userGuid = ValidateUserUid(userGuid);
var deleteEvent = new DeleteUserPreferenceEvent
{
UserUID = userGuid,
PreferenceKeyName = preferencekeyname,
PreferenceKeyUID = preferencekeyuid
};
var result = await WithServiceExceptionTryExecuteAsync(() =>
RequestExecutorContainerFactory
.Build <DeleteUserPreferenceExecutor>(LoggerFactory, ServiceExceptionHandler, PreferenceRepo)
.ProcessAsync(deleteEvent)
);
Logger.LogResult(methodName, $"userGuid: {userGuid}, preferencekeyname: {preferencekeyname}, preferencekeyuid: {preferencekeyuid}", result);
return(result);
}
public void TestDeleteUserPreference_ValidInput_True()
{
//Arrange
DeleteUserPreferenceEvent deleteUser = new DeleteUserPreferenceEvent()
{
PreferenceKeyUID = new Guid("85293f9c-b713-4e95-a5ed-b36beb2c4aa2"),
PreferenceKeyName = "Key",
UserUID = new Guid("fd4b9a47-4b67-40b9-b106-89047c88fa43"),
ActionUTC = DateTime.UtcNow
};
var dbUserPreference = new DbUserPreference()
{
fk_PreferenceKeyID = 10,
fk_UserUID = deleteUser.UserUID,
PreferenceValue = "Json",
SchemaVersion = "1.0",
InsertUTC = DateTime.UtcNow.AddDays(-1),
UpdateUTC = DateTime.UtcNow
};
transaction.Get <DbUserPreference>(Arg.Any <string>()).Returns(x => { return(new List <DbUserPreference>()
{
dbUserPreference
}); });
//Act
bool?result = preferenceService.DeleteUserPreference(deleteUser);
//Assert
Assert.True(result);
transaction.Received(1).Get <DbUserPreference>(Arg.Any <string>());
transaction.Received(1).Delete(Arg.Is <string>(x => x.Contains(deleteUser.UserUID.ToStringAndWrapWithUnhex()) && x.Contains(" = " + dbUserPreference.fk_PreferenceKeyID)));
transaction.Received(1).Publish(Arg.Is <KafkaMessage>(x => x.Key == deleteUser.UserUID.ToString()));
transaction.Received(1).Execute(Arg.Any <List <Action> >());
}
public void DeleteUserPreference_HappyPath()
{
var prefEvent = new CreatePreferenceKeyEvent
{
PreferenceKeyName = $"some key {DateTime.Now.Ticks}",
PreferenceKeyUID = Guid.NewGuid()
};
WriteEventToDb(prefEvent);
var userPrefEvent = new CreateUserPreferenceEvent
{
PreferenceKeyName = prefEvent.PreferenceKeyName,
PreferenceKeyUID = prefEvent.PreferenceKeyUID,
PreferenceJson = "some json here",
SchemaVersion = "1.0",
UserUID = Guid.NewGuid()
};
WriteEventToDb(userPrefEvent);
var userPrefEvent2 = new DeleteUserPreferenceEvent
{
PreferenceKeyName = prefEvent.PreferenceKeyName,
PreferenceKeyUID = prefEvent.PreferenceKeyUID,
UserUID = userPrefEvent.UserUID
};
WriteEventToDb(userPrefEvent2);
}
public bool?DeleteUserPreference(DeleteUserPreferenceEvent userPreference)
{
var dbUserPreference = GetUserPreference(userPreference.UserUID, userPreference.PreferenceKeyUID,
userPreference.PreferenceKeyName);
if (dbUserPreference == null)
{
return(null);
}
var deleteQuery =
string.Format(
"Delete from md_preference_PreferenceUser where fk_UserUID = {0} and fk_PreferenceKeyID = {1}",
userPreference.UserUID.ToStringAndWrapWithUnhex(), dbUserPreference.fk_PreferenceKeyID);
var kafkaMessage = new KafkaMessage()
{
Key = userPreference.UserUID.ToString(),
Message = userPreference
};
var actions = new List <Action>();
actions.Add(() => transaction.Delete(deleteQuery));
actions.Add(() => topics.ToList().ForEach(topic =>
{
kafkaMessage.Topic = topic;
transaction.Publish(kafkaMessage);
}));
return(transaction.Execute(actions));
}
public ActionResult DeleteUserPreference(string preferencekeyname = null, Guid?preferencekeyuid = null,
Guid?userGuid = null)
{
if (!userGuid.HasValue)
{
logger.LogError("UserUID has not been provided");
return(BadRequest("UserUID has not been provided"));
}
if (!preferencekeyuid.HasValue && string.IsNullOrEmpty(preferencekeyname))
{
logger.LogError("preferenceKeyUID or preferenceKeyName should be given");
return(BadRequest("preferenceKeyUID or preferenceKeyName should be given"));
}
try
{
var delEvent = new DeleteUserPreferenceEvent
{
PreferenceKeyUID = preferencekeyuid,
PreferenceKeyName = preferencekeyname,
ActionUTC = DateTime.UtcNow,
UserUID = userGuid.Value
};
bool?isSuccess = _preferenceService.DeleteUserPreference(delEvent);
if (isSuccess.HasValue && isSuccess == true)
{
return(Ok());
}
else if (isSuccess == null)
{
logger.LogError("PreferenceKey does not exist");
return(BadRequest("PreferenceKey does not exist"));
}
logger.LogError("Unable to delete in db");
return(BadRequest("Unable to delete in db"));
}
catch (Exception ex)
{
logger.LogError(ex.Message + ex.StackTrace);
return(StatusCode(500, ex.Message));
}
}
public void DeleteUserPreference_NoExisting()
{
var prefEvent = new CreatePreferenceKeyEvent
{
PreferenceKeyName = $"some key {DateTime.Now.Ticks}",
PreferenceKeyUID = Guid.NewGuid()
};
WriteEventToDb(prefEvent);
var userPrefEvent = new DeleteUserPreferenceEvent
{
PreferenceKeyName = prefEvent.PreferenceKeyName,
PreferenceKeyUID = prefEvent.PreferenceKeyUID,
UserUID = Guid.NewGuid()
};
WriteEventToDb(userPrefEvent, "Non-existent user preference should not be deleted", 0);
}
public async Task DeleteUserPreferenceExecutor_HappyPath()
{
var prefEvent = new DeleteUserPreferenceEvent
{
PreferenceKeyName = "some key",
PreferenceKeyUID = Guid.NewGuid(),
UserUID = Guid.NewGuid(),
};
mockPrefRepo.Setup(p => p.StoreEvent(prefEvent))
.ReturnsAsync(1);
var executor = RequestExecutorContainerFactory.Build <DeleteUserPreferenceExecutor>
(Logger, ServiceExceptionHandler, mockPrefRepo.Object);
var result = await executor.ProcessAsync(prefEvent);
Assert.Equal(ContractExecutionStatesEnum.ExecutedSuccessfully, result.Code);
Assert.Equal(ContractExecutionResult.DefaultMessage, result.Message);
}
public async Task DeleteUserPreferenceExecutor_NoExisting()
{
var prefEvent = new DeleteUserPreferenceEvent
{
PreferenceKeyName = "some key",
PreferenceKeyUID = Guid.NewGuid(),
UserUID = Guid.NewGuid(),
};
mockPrefRepo.Setup(p => p.StoreEvent(prefEvent))
.ReturnsAsync(0);
var executor = RequestExecutorContainerFactory.Build <DeleteUserPreferenceExecutor>
(Logger, ServiceExceptionHandler, mockPrefRepo.Object);
var ex = await Assert.ThrowsAsync <ServiceException>(async() => await executor.ProcessAsync(prefEvent));
Assert.Equal(HttpStatusCode.InternalServerError, ex.Code);
var result = ex.GetResult;
Assert.Equal(2012, result.Code);
Assert.Equal("Unable to delete user preference. ", result.Message);
}
public void TestDeleteUserPreference_PreferenceNotExist_ReturnNull()
{
//Arrange
DeleteUserPreferenceEvent deleteUser = new DeleteUserPreferenceEvent()
{
PreferenceKeyUID = new Guid("85293f9c-b713-4e95-a5ed-b36beb2c4aa2"),
PreferenceKeyName = "Key",
UserUID = new Guid("fd4b9a47-4b67-40b9-b106-89047c88fa43"),
ActionUTC = DateTime.UtcNow
};
transaction.Get <DbUserPreference>(Arg.Any <string>()).Returns(x => { return(new List <DbUserPreference>()); });
//Act
bool?result = preferenceService.DeleteUserPreference(deleteUser);
//Assert
Assert.Null(result);
transaction.Received(1).Get <DbUserPreference>(Arg.Any <string>());
transaction.Received(0).Delete(Arg.Any <string>());
transaction.Received(0).Publish(Arg.Any <KafkaMessage>());
transaction.Received(0).Execute(Arg.Any <List <Action> >());
}
