public IActionResult AssociateCustomerUser([FromBody] AssociateCustomerUserEvent customerUser)
{
try
{
customerUser.ReceivedUTC = DateTime.UtcNow;
if (customerService.GetCustomer(customerUser.CustomerUID) == null)
{
logger.LogInformation(Messages.CustomerDoesntExist);
return(BadRequest(Messages.CustomerDoesntExist));
}
var userCustomerInDb =
userCustomerService.GetCustomerUser(customerUser.CustomerUID, customerUser.UserUID);
if (userCustomerInDb != null)
{
logger.LogInformation(Messages.CustomerUserAlreadyExists);
return(BadRequest(Messages.CustomerUserAlreadyExists));
}
if (userCustomerService.AssociateCustomerUser(customerUser))
{
return(Ok());
}
logger.LogWarning(Messages.UnableToSaveToDb);
return(BadRequest(Messages.UnableToSaveToDb));
}
catch (Exception ex)
{
logger.LogError(string.Format(Messages.ExceptionOccured, ex.Message, ex.StackTrace));
return(StatusCode((int)HttpStatusCode.InternalServerError, ex.Message));
}
}
public static AssociateCustomerUserEvent GetDefaultValidAssociateCustomerUserServiceRequest()
{
AssociateCustomerUserEvent defaultValidAssociateCustomerAssetServiceModel = new AssociateCustomerUserEvent();
defaultValidAssociateCustomerAssetServiceModel.CustomerUID = customerServiceSupport.CreateCustomerModel.CustomerUID;
defaultValidAssociateCustomerAssetServiceModel.UserUID = Guid.NewGuid();
defaultValidAssociateCustomerAssetServiceModel.ActionUTC = DateTime.UtcNow;
defaultValidAssociateCustomerAssetServiceModel.ReceivedUTC = null;
return(defaultValidAssociateCustomerAssetServiceModel);
}
public void AssociateCustomerUser_GivenPayload_ExpectedTransactionStatus(AssociateCustomerUserEvent userEvent,
bool hasValidCustomer, bool transactionStatus, int upsertCalls, int publishCalls, bool hasException)
{
//Arrange
DbCustomer customerData = hasValidCustomer ? new DbCustomer()
{
CustomerID = 109
} : null;
if (hasException)
{
transaction.Get <DbCustomer>(Arg.Any <string>()).Returns(e => throw new Exception());
}
else
{
transaction.Get <DbCustomer>(Arg.Any <string>()).Returns(new List <DbCustomer> {
customerData
});
}
transaction.Execute(Arg.Any <List <Action> >())
.Returns(a =>
{
a.Arg <List <Action> >().ForEach(action => action.Invoke());
return(true);
});
//Act
if (hasException)
{
Assert.Throws <Exception>(() => userCustomerService.AssociateCustomerUser(userEvent));
}
else
{
var resultData = userCustomerService.AssociateCustomerUser(userEvent);
Assert.Equal(transactionStatus, resultData);
}
//Assert
transaction.Received(upsertCalls).Upsert(
Arg.Is <DbUserCustomer>(userCust => ValidateCustomerUserObject(userEvent, userCust, customerData)));
transaction.Received(publishCalls).Publish(
Arg.Is <List <KafkaMessage> >(messages => messages
.TrueForAll(m => ValidateCustomerUserKafkaObject(false, m, userEvent))));
}
public bool AssociateCustomerUser(AssociateCustomerUserEvent associateCustomerUser)
{
try
{
var customer = GetCustomer(associateCustomerUser.CustomerUID);
if (customer?.CustomerID > 0)
{
List <KafkaMessage> messages = CustomerTopics
?.Select(topic => new KafkaMessage
{
Key = associateCustomerUser.CustomerUID.ToString(),
Message = new { AssociateCustomerUserEvent = associateCustomerUser },
Topic = topic
})
?.ToList();
var userCustomer = new DbUserCustomer
{
fk_CustomerID = customer.CustomerID,
fk_CustomerUID = associateCustomerUser.CustomerUID,
fk_UserUID = associateCustomerUser.UserUID,
LastUserUTC = DateTime.UtcNow
};
var actions = new List <Action>
{
() => transaction.Upsert(userCustomer),
() => transaction.Publish(messages)
};
return(transaction.Execute(actions));
}
return(false);
}
catch (Exception ex)
{
logger.LogError($"Error while associating user for customer : {ex.Message}, {ex.StackTrace}");
throw;
}
}
