public IActionResult CreateCustomer([FromBody] CustomerCreateModel customer)
{
if (customer == null || !ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var newCustomer = new CustomerDataTransferObject
{
Name = customer.Name,
Adress = customer.Adress,
Code = customer.Code,
Discount = customer.Discount
};
var newCustomerId = _customerService.CreateCustomer(newCustomer);
var customerUser = new CustomerInfoDataTransferObject
{
UserName = customer.Email,
Email = customer.Email,
CustomerId = newCustomerId
};
_customerService.AddCustomerUser(_userManager, customerUser, customer.Password).Wait();
return(CreatedAtRoute("GetCustomer", new { id = newCustomerId },
new CustomerGetModel
{
Id = newCustomerId,
Name = newCustomer.Name,
Code = newCustomer.Code,
Adress = newCustomer.Adress,
Discount = newCustomer.Discount
}));
}
public async Task PutAsyncNonExistingCustomerReturns404NotFound()
{
using (var customersDataProvider = CreateTestCustomerDataProvider(SampleListOfCustomerDataTransferObjects))
{
// arrange
var testLogger = CreateTestLogger();
var customersController = CreateTestCustomersController(customersDataProvider, testLogger);
var customerUpdateInfo = new CustomerDataTransferObject
{
FirstName = "Joe",
LastName = "Smith",
PhoneNumber = "555-555-5555"
};
// act
var guid = Guid.NewGuid();
var result = await customersController.PutAsync(guid, customerUpdateInfo);
// assert
var expectedErrorMessage = string.Format(CustomerNotFoundErrorText, guid);
Assert.Equal(StatusCodes.Status404NotFound, result.StatusCode);
Assert.Equal(expectedErrorMessage, result.Value);
VerifyLogMessage(testLogger, $"PutAsync: {expectedErrorMessage}", LogLevel.Error, 1);
}
}
public async Task PutAsyncExistingCustomerInformationUpdatesAndReturns200OK()
{
using (var customersDataProvider = CreateTestCustomerDataProvider(SampleListOfCustomerDataTransferObjects))
{
// arrange
var testLogger = CreateTestLogger();
var customersController = CreateTestCustomersController(customersDataProvider, testLogger);
var customerUpdateInfo = new CustomerDataTransferObject
{
FirstName = "Joe",
LastName = "Smith",
PhoneNumber = "555-555-5555"
};
// act
var customerToUpdateId = customersDataProvider.GetCustomers().First().Id;
await customersController.PutAsync(customerToUpdateId, customerUpdateInfo);
// assert logging
Assert.Equal(2, testLogger.LoggedMessages.Count);
VerifyLogMessage(testLogger, string.Format(LoggingUpdatingCustomerText, customerToUpdateId));
VerifyLogMessage(testLogger, string.Format(LoggingUpdatedCustomerText, customerToUpdateId), LogLevel.Information, 1);
// assert information updated
var customerToUpdate = customersController.Get(customerToUpdateId);
Assert.NotNull(customerToUpdate);
Assert.Equal(StatusCodes.Status200OK, customerToUpdate.StatusCode);
Assert.Equal("Joe", ((CustomerEntity)customerToUpdate.Value).FirstName);
Assert.Equal("Smith", ((CustomerEntity)customerToUpdate.Value).LastName);
}
}
/// <summary>
/// Adds a customer using the customerDataTransferObject
/// </summary>
public async Task <CustomerEntity> AddCustomerAsync(CustomerDataTransferObject customerDataTransferObject)
{
if (customerDataTransferObject == null)
{
throw new ArgumentNullException();
}
if (!customerDataTransferObject.ValidateCustomerDataTransferObject())
{
throw new ArgumentException();
}
var newCustomerEntity = new CustomerEntity();
UpdateCustomerInfo(newCustomerEntity, customerDataTransferObject);
var customerEntityAdded = Customers.Add(newCustomerEntity);
if (customerEntityAdded?.Entity == null)
{
return(null);
}
await SaveChangesAsync();
return(customerEntityAdded.Entity);
}
public async Task TryUpdateCustomerAsyncExistingCustomerInformationUpdatesAndReturnsTrue()
{
using (var customersDataProvider = CreateTestCustomerDataProvider(SampleListOfCustomerDataTransferObjects))
{
// arrange
var customerToUpdateId = customersDataProvider.GetCustomers().First().Id;
var customerDataTransferObject = new CustomerDataTransferObject
{
FirstName = "Joe",
LastName = "Smith",
PhoneNumber = "555-555-5555"
};
// act
var customerDataActionResult =
await customersDataProvider.TryUpdateCustomerAsync(customerToUpdateId, customerDataTransferObject);
// assert
Assert.True(customerDataActionResult.IsSuccess);
Assert.Equal("Joe", customerDataActionResult.CustomerEntity.FirstName);
Assert.Equal("Smith", customerDataActionResult.CustomerEntity.LastName);
// assert
var customerToUpdate = customersDataProvider.FindCustomer(customerToUpdateId);
Assert.NotNull(customerToUpdate);
Assert.Equal("Joe", customerToUpdate.FirstName);
Assert.Equal("Smith", customerToUpdate.LastName);
}
}
public async Task <ObjectResult> PutAsync(Guid id, [FromBody] CustomerDataTransferObject customerDataTransferObject)
{
if (customerDataTransferObject == null || !customerDataTransferObject.ValidateCustomerDataTransferObject())
{
_logger.LogError(BuildLogInfo(nameof(PutAsync), "CustomerInfoInvalid"));
return(BadRequest(BuildStringFromResource("CustomerInfoInvalid")));
}
_logger.LogInformation(BuildLogInfo(nameof(PutAsync), "LoggingUpdatingCustomer", id));
if (!_customersDataProvider.CustomerExists(id))
{
_logger.LogError(BuildLogInfo(nameof(PutAsync), "CustomerNotFound", id));
return(new NotFoundObjectResult(BuildStringFromResource("CustomerNotFound", id)));
}
var customerDataActionResult = await _customersDataProvider.TryUpdateCustomerAsync(id, customerDataTransferObject);
if (!customerDataActionResult.IsSuccess)
{
_logger.LogError(BuildLogInfo(nameof(PutAsync), "UnexpectedServerError"));
return(StatusCode(StatusCodes.Status500InternalServerError, BuildStringFromResource("UnexpectedServerError")));
}
_logger.LogInformation(BuildLogInfo(nameof(PutAsync), "LoggingUpdatedCustomer", id));
return(Ok(customerDataActionResult.CustomerEntity));
}
public async Task PostAsyncWithValidCustomerInfoAddsCustomerAndReturns200OK()
{
using (var customersDataProvider = CreateCustomersDataProvider())
{
// arrange
var testLogger = CreateTestLogger();
var customersController = CreateTestCustomersController(customersDataProvider, testLogger);
var newCustomer = new CustomerDataTransferObject
{
FirstName = "Jon",
LastName = "Smith",
PhoneNumber = "555-555-5555"
};
// act
// Pass the ResourceManager explicitly since there's no global service provider to provide it
var result = await customersController.PostAsync(newCustomer, _serviceProvider.GetRequiredService <ResourceManager>());
// assert status code
Assert.Equal(StatusCodes.Status200OK, result.StatusCode);
// assert logging
var customerName = $"{newCustomer.FirstName} {newCustomer.LastName}";
Assert.Equal(2, testLogger.LoggedMessages.Count);
VerifyLogMessage(testLogger, string.Format(LoggingAddingCustomerText, customerName));
VerifyLogMessage(testLogger, string.Format(LoggingAddedCustomerText, customerName), LogLevel.Information, 1);
// assert customer was added
var customersResult = customersController.Get();
Assert.Equal(1, customersResult.Count());
var customerResult = customersResult.First();
Assert.Equal(newCustomer.FirstName, customerResult.FirstName);
Assert.Equal(newCustomer.LastName, customerResult.LastName);
}
}
/// <summary>
/// Ensures each customer property except id are equal in both customer objects
/// </summary>
internal void CompareCustomers(CustomerDataTransferObject customerInfo, CustomerEntity customerEntity)
{
foreach (var item in customerInfo.GetType().GetTypeInfo().GetProperties())
{
var customerEntityPropertyInfo = GetCustomerEntityPropertyInfo(item);
Assert.Equal(customerEntityPropertyInfo.GetValue(customerEntity), item.GetValue(customerInfo));
}
}
public async Task AddCustomerAsyncWithNullCustomerInfoThrowsArgumentNullException()
{
using (var customersDataProvider = CreateCustomersDataProvider())
{
CustomerDataTransferObject customerInfo = null;
await Assert.ThrowsAsync <ArgumentNullException>(async() => await customersDataProvider.AddCustomerAsync(customerInfo));
}
}
/// <summary>
/// Updates an existing customer's information to the customerDataTransferObject
/// </summary>
public async Task <CustomerEntity> UpdateCustomerAsync(Guid id, CustomerDataTransferObject customerDataTransferObject)
{
var customerEntity = FindCustomer(id);
UpdateCustomerInfo(customerEntity, customerDataTransferObject);
await SaveChangesAsync();
return(customerEntity);
}
public void UpdateCustomerAfterJsonPatchDocument(CustomerDataTransferObject customerModified)
{
_database.Customers.Update(new Customer
{
Name = customerModified.Name,
Code = customerModified.Code,
Adress = customerModified.Adress,
Discount = customerModified.Discount
});
_database.Save();
}
public async Task <IActionResult> AddCustomer(CustomerDataTransferObject customer)
{
SetCorrelationId();
if (ModelState.IsValid)
{
await _customersService.AddCustomerAsync(customer);
return(RedirectToAction(nameof(CustomersList)));
}
return(View(customer));
}
public async Task TryAddCustomerAsyncWithInvalidCustomerInfoReturnsFalse()
{
using (var customersDataProvider = CreateCustomersDataProvider())
{
// arrange
var customerDataTransferObject = new CustomerDataTransferObject();
// Assert
var result = await customersDataProvider.TryAddCustomerAsync(customerDataTransferObject);
Assert.False(result.IsSuccess);
Assert.Null(result.CustomerEntity);
}
}
public Guid CreateCustomer(CustomerDataTransferObject customer)
{
Guid Id = Guid.NewGuid();
_database.Customers.Create(new Customer
{
Id = Id,
Name = customer.Name,
Code = customer.Code,
Adress = customer.Adress,
Discount = customer.Discount
});
_database.Save();
return(Id);
}
/// <summary>
/// Updates an existing customer's information with the customerDataTransferObject
/// </summary>
private void UpdateCustomerInfo(CustomerEntity customerEntity,
CustomerDataTransferObject customerDataTransferObject)
{
if (customerEntity == null ||
customerDataTransferObject == null ||
!customerDataTransferObject.ValidateCustomerDataTransferObject())
{
throw new ArgumentException();
}
foreach (var item in customerDataTransferObject.GetType().GetTypeInfo().GetProperties())
{
var desinationPropertyInfo = typeof(CustomerEntity).GetProperty(item.Name);
desinationPropertyInfo?.SetValue(customerEntity, item.GetValue(customerDataTransferObject));
}
}
/// <summary>
/// Returns a list of customers
/// </summary>
public async Task <IActionResult> AddCustomerAsync(CustomerDataTransferObject customer)
{
var query = "/Api/Customers";
var content = new StringContent(JsonConvert.SerializeObject(customer), Encoding.UTF8, "application/json");
try
{
var result = await ExecuteWithResiliencePolicies(() => _client.PostAsync(query, content));
return(new StatusCodeResult((int)result.StatusCode));
}
catch (HttpRequestException)
{
return(new StatusCodeResult(StatusCodes.Status503ServiceUnavailable));
}
}
/// <summary>
/// Tries to add a customer. If the customer is added, then returns true
/// </summary>
public async Task <CustomerDataActionResult> TryAddCustomerAsync(CustomerDataTransferObject customerDataTransferObject)
{
try
{
var customerEntity = await AddCustomerAsync(customerDataTransferObject);
if (customerEntity == null)
{
return(_failedCustomerDataActionResult);
}
return(new CustomerDataActionResult(true, customerEntity));
}
catch
{
return(_failedCustomerDataActionResult);
}
}
public async Task UpdateAsyncNonExistingCustomerThrowsInvalidOperationException()
{
using (var customersDataProvider = CreateTestCustomerDataProvider(SampleListOfCustomerDataTransferObjects))
{
// arrange
var customerDataTransferObject = new CustomerDataTransferObject
{
FirstName = "Joe",
LastName = "Smith",
PhoneNumber = "555-555-5555"
};
var guid = Guid.NewGuid();
// assert
await Assert.ThrowsAsync <InvalidOperationException>(async() => await
customersDataProvider.UpdateCustomerAsync(guid, customerDataTransferObject));
}
}
public async Task AddCustomerAsyncWithValidCustomerInfoAddsCustomer()
{
using (var customersDataProvider = CreateCustomersDataProvider())
{
// arrange
var customerInfo = new CustomerDataTransferObject
{
FirstName = "Jon",
LastName = "Smith",
PhoneNumber = "555-555-5555"
};
// act
var result = await customersDataProvider.AddCustomerAsync(customerInfo);
// assert
Assert.NotEqual(Guid.Empty, result.Id);
Assert.Equal(customerInfo.FirstName, result.FirstName);
Assert.Equal(customerInfo.LastName, result.LastName);
}
}
public async Task TryUpdateCustomerAsyncNonExistingCustomerReturnsFalse()
{
using (var customersDataProvider = CreateTestCustomerDataProvider(SampleListOfCustomerDataTransferObjects))
{
// arrange
var customerDataTransferObject = new CustomerDataTransferObject
{
FirstName = "Joe",
LastName = "Smith",
PhoneNumber = "555-555-5555"
};
var guid = Guid.NewGuid();
// act
var customerDataActionResult =
await customersDataProvider.TryUpdateCustomerAsync(guid, customerDataTransferObject);
// assert
Assert.False(customerDataActionResult.IsSuccess);
Assert.Null(customerDataActionResult.CustomerEntity);
}
}
/// <summary>
/// Tries to update an existing customer with the customerDataTransferObject
/// </summary>
public async Task <CustomerDataActionResult> TryUpdateCustomerAsync(Guid id, CustomerDataTransferObject customerDataTransferObject)
{
if (!CustomerExists(id))
{
return(_failedCustomerDataActionResult);
}
try
{
var customerEntity = await UpdateCustomerAsync(id, customerDataTransferObject);
if (customerEntity == null)
{
return(_failedCustomerDataActionResult);
}
return(new CustomerDataActionResult(true, customerEntity));
}
catch
{
return(_failedCustomerDataActionResult);
}
}
public async Task <ObjectResult> PostAsync([FromBody] CustomerDataTransferObject customerDataTransferObject,
[FromServices] ResourceManager resourceManager)
{
if (customerDataTransferObject == null || !customerDataTransferObject.ValidateCustomerDataTransferObject())
{
_logger.LogError(BuildLogInfo(nameof(PostAsync), "CustomerInfoInvalid"));
return(BadRequest(BuildStringFromResource("CustomerInfoInvalid")));
}
var customerName = $"{customerDataTransferObject.FirstName} {customerDataTransferObject.LastName}";
_logger.LogInformation(BuildLogInfo(nameof(PostAsync), "LoggingAddingCustomer", customerName));
var customerDataActionResult = await _customersDataProvider.TryAddCustomerAsync(customerDataTransferObject);
if (!customerDataActionResult.IsSuccess)
{
_logger.LogError(BuildLogInfo(nameof(PostAsync), "UnexpectedServerError"));
return(StatusCode(StatusCodes.Status500InternalServerError, BuildStringFromResource("UnexpectedServerError")));
}
_logger.LogInformation(BuildLogInfo(nameof(PostAsync), "LoggingAddedCustomer", customerName));
return(Ok(customerDataActionResult.CustomerEntity));
}
