public ActionResult UpdatePreferenceKey([FromBody] UpdatePreferenceKeyEvent preferenceEvent) { try { bool?isSuccess = _preferenceService.UpdatePreferenceKey(preferenceEvent); 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 save to db. Make sure request is not duplicated and all keys exist"); return(BadRequest("Unable to save to db. Make sure request is not duplicated and all keys exist")); } catch (Exception ex) { if (ex.Message.Contains("PreferenceKey Name Already Exist")) { return(BadRequest("PreferenceKey Name Already Exist")); } logger.LogError(ex.Message + ex.StackTrace); return(StatusCode(500, ex.Message)); } }
public void TestUpdatePreferenceKey_ValidInput_True() { //Arrange UpdatePreferenceKeyEvent updatePreference = new UpdatePreferenceKeyEvent() { PreferenceKeyUID = new Guid("2ae9019e-b840-4121-8639-366eecac91c1"), PreferenceKeyName = "Key", ActionUTC = DateTime.UtcNow }; var dbPreferenceKey = new PreferenceKeyDto() { PreferenceKeyUID = new Guid("2ae9019e-b840-4121-8639-366eecac91c1"), PreferenceKeyName = "Key", InsertUTC = DateTime.UtcNow.AddDays(-1), UpdateUTC = DateTime.UtcNow }; transaction.Get <PreferenceKeyDto>(Arg.Is <string>(x => x.Contains("PreferenceKeyUID"))).Returns(x => { return(new List <PreferenceKeyDto>() { dbPreferenceKey }); }); //Act bool?result = preferenceService.UpdatePreferenceKey(updatePreference); //Assert Assert.True(result); transaction.Received(2).Get <PreferenceKeyDto>(Arg.Any <string>()); transaction.Received(1).Upsert(Arg.Is <DbPreferenceKey>(x => x.PreferenceKeyUID == updatePreference.PreferenceKeyUID && x.PreferenceKeyName == updatePreference.PreferenceKeyName)); transaction.Received(1).Publish(Arg.Is <KafkaMessage>(x => x.Key == updatePreference.PreferenceKeyUID.ToString())); transaction.Received(1).Execute(Arg.Any <List <Action> >()); }
public async Task UpdatePreferenceKeyExecutor_DuplicateKeyName() { const string keyName = "some key"; var prefKeyDatabase = new PrefKeyDataModel { KeyName = keyName, PreferenceKeyUID = Guid.NewGuid().ToString(), PreferenceKeyID = 12345 }; mockPrefRepo.Setup(p => p.GetPreferenceKey(null, keyName)) .ReturnsAsync(prefKeyDatabase); var prefEvent = new UpdatePreferenceKeyEvent { PreferenceKeyName = keyName, PreferenceKeyUID = Guid.NewGuid() }; var executor = RequestExecutorContainerFactory.Build <UpdatePreferenceKeyExecutor> (Logger, ServiceExceptionHandler, mockPrefRepo.Object); var ex = await Assert.ThrowsAsync <ServiceException>(async() => await executor.ProcessAsync(prefEvent)); Assert.Equal(HttpStatusCode.BadRequest, ex.Code); var result = ex.GetResult; Assert.Equal(2004, result.Code); Assert.Equal($"Duplicate preference key name. {keyName}", result.Message); }
public async Task UpdatePreferenceKeyExecutor_MissingKeyUID() { const string keyName = "some key"; var keyUid = Guid.NewGuid(); var prefKeyDatabase = new PrefKeyDataModel { KeyName = keyName, PreferenceKeyUID = keyUid.ToString(), PreferenceKeyID = 12345 }; mockPrefRepo.Setup(p => p.GetPreferenceKey(null, keyName)) .ReturnsAsync((PrefKeyDataModel)null); var prefEvent = new UpdatePreferenceKeyEvent { PreferenceKeyName = "some other key", PreferenceKeyUID = keyUid }; mockPrefRepo.Setup(p => p.StoreEvent(prefEvent)) .ReturnsAsync(0); var executor = RequestExecutorContainerFactory.Build <UpdatePreferenceKeyExecutor> (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(2003, result.Code); Assert.Equal("Unable to update preference key. ", result.Message); }
public void UpdatePreferenceKey_NoExisting() { var prefEvent = new UpdatePreferenceKeyEvent { PreferenceKeyName = $"some key {DateTime.Now.Ticks}", PreferenceKeyUID = Guid.NewGuid() }; WriteEventToDb(prefEvent, "Non-existent preference key should not be updated", 0); }
public async Task <PreferenceKeyV1Result> UpdatePreferenceKey([FromBody] UpdatePreferenceKeyEvent preferenceEvent) { var methodName = $"{nameof(UpdatePreferenceKey)}"; Logger.LogInformation($"{methodName} preferenceEvent: {0}", JsonConvert.SerializeObject(preferenceEvent)); var result = await WithServiceExceptionTryExecuteAsync(() => RequestExecutorContainerFactory .Build <UpdatePreferenceKeyExecutor>(LoggerFactory, ServiceExceptionHandler, PreferenceRepo) .ProcessAsync(preferenceEvent) ) as PreferenceKeyV1Result; Logger.LogResult(methodName, JsonConvert.SerializeObject(preferenceEvent), result); return(result); }
public void UpdatePreferenceKey_DuplicateKeyName() { var prefEvent = new CreatePreferenceKeyEvent { PreferenceKeyName = $"some key {DateTime.Now.Ticks}", PreferenceKeyUID = Guid.NewGuid() }; WriteEventToDb(prefEvent); var prefEvent2 = new UpdatePreferenceKeyEvent { PreferenceKeyName = prefEvent.PreferenceKeyName, PreferenceKeyUID = Guid.NewGuid() }; WriteEventToDb(prefEvent2, "Preference key with duplicate name should not be updated", 0); }
public void UpdatePreferenceKey_HappyPath() { var prefEvent = new CreatePreferenceKeyEvent { PreferenceKeyName = $"some key {DateTime.Now.Ticks}", PreferenceKeyUID = Guid.NewGuid() }; WriteEventToDb(prefEvent); var prefEvent2 = new UpdatePreferenceKeyEvent { PreferenceKeyName = $"updated key {DateTime.Now.Ticks}", PreferenceKeyUID = prefEvent.PreferenceKeyUID }; WriteEventToDb(prefEvent2); }
public void TestUpdatePreferenceKey_InvalidPreference_ReturnFalse() { //Arrange UpdatePreferenceKeyEvent updatePreference = new UpdatePreferenceKeyEvent() { PreferenceKeyUID = new Guid("2ae9019e-b840-4121-8639-366eecac91c1"), PreferenceKeyName = "Key", ActionUTC = DateTime.UtcNow }; transaction.Get <PreferenceKeyDto>(Arg.Any <string>()).Returns(x => { return(new List <PreferenceKeyDto>()); }); //Act bool?result = preferenceService.UpdatePreferenceKey(updatePreference); //Assert Assert.Null(result); transaction.Received(1).Get <PreferenceKeyDto>(Arg.Any <string>()); transaction.Received(0).Upsert <DbPreferenceKey>(Arg.Any <DbPreferenceKey>()); transaction.Received(0).Publish(Arg.Any <KafkaMessage>()); transaction.Received(0).Execute(Arg.Any <List <Action> >()); }
public async Task UpdatePreferenceKeyExecutor_HappyPath() { const string keyName = "some key"; const string newKeyName = "some other key"; var keyUid = Guid.NewGuid(); mockPrefRepo.Setup(p => p.GetPreferenceKey(null, keyName)) .ReturnsAsync((PrefKeyDataModel)null); var prefEvent = new UpdatePreferenceKeyEvent { PreferenceKeyName = newKeyName, PreferenceKeyUID = keyUid }; mockPrefRepo.Setup(p => p.StoreEvent(prefEvent)) .ReturnsAsync(1); var prefKeyDatabase = new PrefKeyDataModel { KeyName = newKeyName, PreferenceKeyUID = keyUid.ToString(), PreferenceKeyID = 12345 }; mockPrefRepo.Setup(p => p.GetPreferenceKey(keyUid, newKeyName)) .ReturnsAsync(prefKeyDatabase); var executor = RequestExecutorContainerFactory.Build <UpdatePreferenceKeyExecutor> (Logger, ServiceExceptionHandler, mockPrefRepo.Object); var result = await executor.ProcessAsync(prefEvent) as PreferenceKeyV1Result; Assert.Equal(ContractExecutionStatesEnum.ExecutedSuccessfully, result.Code); Assert.Equal(ContractExecutionResult.DefaultMessage, result.Message); Assert.Equal(prefEvent.PreferenceKeyName, result.PreferenceKeyName); Assert.Equal(prefEvent.PreferenceKeyUID, result.PreferenceKeyUID); }
public bool?UpdatePreferenceKey(UpdatePreferenceKeyEvent preferenceKey) { var preference = GetPreferenceKey(preferenceKey.PreferenceKeyUID); if (preference == null) { return(null); } if (GetPreferenceKey(null, preferenceKey.PreferenceKeyName) != null) { throw new Exception("PreferenceKey Name Already Exist"); } var updatePreferenceKey = new DbPreferenceKey() { PreferenceKeyName = preferenceKey.PreferenceKeyName, PreferenceKeyUID = preferenceKey.PreferenceKeyUID.Value, UpdateUTC = DateTime.UtcNow }; var kafkaMessage = new KafkaMessage() { Key = preferenceKey.PreferenceKeyUID.ToString(), Message = new { UpdateUserPreferenceKeyEvent = preferenceKey } }; var actions = new List <Action>(); actions.Add(() => transaction.Upsert <DbPreferenceKey>(updatePreferenceKey)); actions.Add(() => topics.ToList().ForEach(topic => { kafkaMessage.Topic = topic; transaction.Publish(kafkaMessage); })); return(transaction.Execute(actions)); }
/// <summary> /// Create an instance of the master data events. Convert to JSON. /// </summary> /// <param name="eventObject">event to be published</param> /// <returns>json string with event serialized</returns> private string BuildEventIntoObject(dynamic eventObject) { var jsonString = string.Empty; string eventType = eventObject.EventType; switch (eventType) { case "CreateUserPreferenceRequest": case "UpdateUserPreferenceRequest": var request = new UpsertUserPreferenceRequest(); if (HasProperty(eventObject, "TargetUserUID")) { request.TargetUserUID = Guid.Parse(eventObject.TargetUserUID); } if (HasProperty(eventObject, "SchemaVersion")) { request.SchemaVersion = eventObject.SchemaVersion; } if (HasProperty(eventObject, "PreferenceJson")) { request.PreferenceJson = eventObject.PreferenceJson; } if (HasProperty(eventObject, "PreferenceKeyName")) { request.PreferenceKeyName = eventObject.PreferenceKeyName; } if (HasProperty(eventObject, "PreferenceKeyUID")) { request.PreferenceKeyUID = Guid.Parse(eventObject.PreferenceKeyUID); } jsonString = JsonConvert.SerializeObject(request, JsonSettings); break; case "CreatePreferenceKeyEvent": var createPrefKeyEvent = new CreatePreferenceKeyEvent { PreferenceKeyName = eventObject.PreferenceKeyName, PreferenceKeyUID = Guid.Parse(eventObject.PreferenceKeyUID) }; jsonString = JsonConvert.SerializeObject(createPrefKeyEvent, JsonSettings); break; case "UpdatePreferenceKeyEvent": var updatePrefKeyEvent = new UpdatePreferenceKeyEvent { PreferenceKeyName = eventObject.PreferenceKeyName, PreferenceKeyUID = Guid.Parse(eventObject.PreferenceKeyUID) }; jsonString = JsonConvert.SerializeObject(updatePrefKeyEvent, JsonSettings); break; case "DeletePreferenceKeyEvent": var deletePrefKeyEvent = new DeletePreferenceKeyEvent { PreferenceKeyUID = Guid.Parse(eventObject.PreferenceKeyUID) }; jsonString = JsonConvert.SerializeObject(deletePrefKeyEvent, JsonSettings); break; } return(jsonString); }