public async Task EditAddress_ReturnsViewModel(
[Frozen] Mock <ICustomerService> customerService,
EditCustomerAddressViewModel viewModel,
[Greedy] CustomerController sut
)
{
//Arrange
customerService.Setup(x => x.GetCustomerAddress(
It.IsAny <string>(),
It.IsAny <string>()
))
.ReturnsAsync(viewModel);
//Act
var actionResult = await sut.EditAddress("AW00000001", "Main Office");
//Assert
var viewResult = actionResult.Should().BeAssignableTo <ViewResult>().Subject;
viewResult.Model.Should().Be(viewModel);
viewResult.ViewName.Should().Be("Address");
viewResult.ViewData["addressTypes"].Should().NotBeNull();
viewResult.ViewData["countries"].Should().NotBeNull();
viewResult.ViewData["statesProvinces"].Should().NotBeNull();
}
public async Task <EditCustomerAddressViewModel> GetCustomerAddress(string accountNumber, string addressType)
{
logger.LogInformation("GetCustomerAddress called");
var customer = await customerApiClient.GetCustomerAsync(accountNumber);
Guard.Against.Null(customer, nameof(customer));
var address = customer.Addresses.FirstOrDefault(a => a.AddressType == addressType);
Guard.Against.Null(address, nameof(address));
var countries = await GetCountries();
Guard.Against.Null(countries, nameof(countries));
var countryRegionCode = countries.FirstOrDefault(c => c.Text == address.Address.Country).Value;
Guard.Against.NullOrEmpty(countryRegionCode, nameof(countryRegionCode));
var vm = new EditCustomerAddressViewModel
{
AccountNumber = accountNumber,
CustomerName = customer.CustomerName,
CustomerAddress = mapper.Map <CustomerAddressViewModel>(address),
AddressTypes = await GetAddressTypes(),
Countries = countries,
StateProvinces = await GetStateProvinces(countryRegionCode)
};
return(vm);
}
public async Task AddAddressGet_ReturnsViewModel(
[Frozen] Mock <ICustomerService> customerService,
EditCustomerAddressViewModel viewModel,
[Greedy] CustomerController sut
)
{
//Arrange
customerService.Setup(x => x.AddAddress(
It.IsAny <string>(),
It.IsAny <string>()
))
.Returns(viewModel);
//Act
var actionResult = await sut.AddAddress(
viewModel.AccountNumber,
viewModel.CustomerName
);
//Assert
var viewResult = actionResult.Should().BeAssignableTo <ViewResult>().Subject;
viewResult.Model.Should().Be(viewModel);
viewResult.ViewData["addressTypes"].Should().NotBeNull();
viewResult.ViewData["countries"].Should().NotBeNull();
viewResult.ViewData["statesProvinces"].Should().NotBeNull();
}
public async Task <IActionResult> EditAddress(EditCustomerAddressViewModel viewModel)
{
if (ModelState.IsValid)
{
await customerService.UpdateAddress(viewModel);
return(RedirectToAction("Detail", new { viewModel.AccountNumber }));
}
return(View(viewModel));
}
public ActionResult Edit(int id, int customerId)
{
var model = new EditCustomerAddressViewModel();
prepareEditModel(model, id, customerId);
model.CustomerAddress = CustomerService.FindCustomerAddressModel(id, model.CurrentCompany, customerId);
model.LGS = CustomerService.LockCustomerAddress(model.CustomerAddress);
return(View(model));
}
public async Task UpdateAddress_OK()
{
//Arrange
var mockLogger = new Mock <ILogger <CustomerService> >();
var mockCustomerApi = new Mock <customerApi.ICustomerApiClient>();
var mockReferenceDataApi = new Mock <referenceDataApi.IReferenceDataApiClient>();
var mockSalesPersonApi = new Mock <salesPersonApi.ISalesPersonApiClient>();
mockCustomerApi.Setup(x => x.GetCustomerAsync(It.IsAny <string>()))
.ReturnsAsync(
new StoreCustomerBuilder()
.WithTestValues()
.Build()
);
var svc = new CustomerService(
mockLogger.Object,
Mapper.CreateMapper(),
mockCustomerApi.Object,
mockReferenceDataApi.Object,
mockSalesPersonApi.Object
);
//Act
var viewModel = new EditCustomerAddressViewModel
{
AccountNumber = "AW00000001",
CustomerAddress = new CustomerAddressViewModel
{
AddressType = "Main Office",
Address = new AddressViewModel
{
AddressLine1 = "2251 Elliot Avenue",
PostalCode = "98104",
City = "Seattle",
StateProvinceCode = "WA",
CountryRegionCode = "US"
}
}
};
await svc.UpdateAddress(viewModel);
//Assert
mockCustomerApi.Verify(x => x.UpdateCustomerAsync(
It.IsAny <string>(),
It.IsAny <customerApi.Models.UpdateCustomer.Customer>()
));
}
public async Task EditAddressPost_InvalidModelState_ReturnsViewModel(
EditCustomerAddressViewModel viewModel,
[Greedy] CustomerController sut
)
{
//Arrange
sut.ModelState.AddModelError("AccountNumber", "AW00000001");
//Act
var actionResult = await sut.EditAddress(viewModel);
//Assert
var viewResult = actionResult.Should().BeAssignableTo <ViewResult>().Subject;
viewResult.Model.Should().Be(viewModel);
}
public async Task AddAddressPost_ValidModelState_ReturnsRedirect(
EditCustomerAddressViewModel viewModel,
[Greedy] CustomerController sut
)
{
//Act
var actionResult = await sut.AddAddress(viewModel);
//Assert
var redirectResult = actionResult.Should().BeAssignableTo <RedirectToActionResult>().Subject;
redirectResult.ActionName.Should().Be("Detail");
redirectResult.RouteValues.Count.Should().Be(1);
redirectResult.RouteValues.ContainsKey("AccountNumber");
redirectResult.RouteValues.Values.Contains(viewModel.AccountNumber);
}
void prepareEditModel(EditCustomerAddressViewModel model, int id, int customerId)
{
var customer = CustomerService.FindCustomerModel(customerId, CurrentCompany);
string title = EvolutionResources.bnrAddEditCustomerAddress + (customer == null ? "" : " - " + customer.Name);
if (id <= 0)
{
title += " - " + EvolutionResources.lblNewAddress;
}
PrepareViewModel(model, title, customerId, MakeMenuOptionFlags(customerId, 0));
model.AddressTypeList = LookupService.FindLOVItemsListItemModel(null, LOVName.AddressType);
model.CountryList = LookupService.FindCountriesListItemModel();
model.ParentId = customerId;
}
public EditCustomerAddressViewModel AddAddress(string accountNumber, string customerName)
{
logger.LogInformation("AddAddress called");
var vm = new EditCustomerAddressViewModel
{
IsNewAddress = true,
AccountNumber = accountNumber,
CustomerName = customerName,
CustomerAddress = new CustomerAddressViewModel {
Address = new AddressViewModel
{
CountryRegionCode = "US"
}
}
};
return(vm);
}
public async Task EditAddressPost_ValidModelState_ReturnsRedirect(
[Frozen] Mock <ICustomerService> customerService,
EditCustomerAddressViewModel viewModel,
[Greedy] CustomerController sut
)
{
//Act
var actionResult = await sut.EditAddress(viewModel);
//Assert
customerService.Verify(x => x.UpdateAddress(It.IsAny <EditCustomerAddressViewModel>()));
var redirectResult = actionResult.Should().BeAssignableTo <RedirectToActionResult>().Subject;
redirectResult.ActionName.Should().Be("Detail");
redirectResult.RouteValues.Count.Should().Be(1);
redirectResult.RouteValues.ContainsKey("AccountNumber");
redirectResult.RouteValues.Values.Contains(viewModel.AccountNumber);
}
public async Task <EditCustomerAddressViewModel> GetCustomerAddress(string accountNumber, string addressType)
{
logger.LogInformation("GetCustomerAddress called");
var customer = await customerApiClient.GetCustomerAsync(accountNumber);
Guard.Against.Null(customer, nameof(customer));
var address = customer.Addresses.FirstOrDefault(a => a.AddressType == addressType);
Guard.Against.Null(address, nameof(address));
var vm = new EditCustomerAddressViewModel
{
AccountNumber = accountNumber,
CustomerName = customer.CustomerName,
CustomerAddress = mapper.Map <CustomerAddressViewModel>(address),
};
return(vm);
}
public async Task <EditCustomerAddressViewModel> AddAddress(string accountNumber, string customerName)
{
logger.LogInformation("AddAddress called");
var vm = new EditCustomerAddressViewModel
{
IsNewAddress = true,
AccountNumber = accountNumber,
CustomerName = customerName,
CustomerAddress = new CustomerAddressViewModel {
Address = new AddressViewModel
{
Country = "United States"
}
},
AddressTypes = await GetAddressTypes(),
Countries = await GetCountries(),
StateProvinces = await GetStateProvinces("US")
};
return(vm);
}
public async Task UpdateAddress(EditCustomerAddressViewModel viewModel)
{
logger.LogInformation("UpdateAddress called");
logger.LogInformation("Getting customer for {AccountNumber}", viewModel.AccountNumber);
var customer = await customerApiClient.GetCustomerAsync(viewModel.AccountNumber);
logger.LogInformation("Retrieved customer {@Customer}", customer);
Guard.Against.Null(customer, nameof(customer));
var customerToUpdate = mapper.Map <ApiClients.CustomerApi.Models.UpdateCustomer.Customer>(customer);
Guard.Against.Null(customerToUpdate, nameof(customerToUpdate));
var addressToUpdate = customerToUpdate.Addresses.FirstOrDefault(a => a.AddressType == viewModel.CustomerAddress.AddressType);
Guard.Against.Null(addressToUpdate, nameof(addressToUpdate));
mapper.Map(viewModel.CustomerAddress.Address, addressToUpdate.Address);
logger.LogInformation("Updating customer {@Customer}", customer);
await customerApiClient.UpdateCustomerAsync(viewModel.AccountNumber, customerToUpdate);
logger.LogInformation("Customer updated successfully");
}
public async Task AddAddress(EditCustomerAddressViewModel viewModel)
{
logger.LogInformation("AddAddress called");
logger.LogInformation("Getting customer for {AccountNumber}", viewModel.AccountNumber);
var customer = await customerApiClient.GetCustomerAsync(viewModel.AccountNumber);
logger.LogInformation("Retrieved customer {@Customer}", customer);
Guard.Against.Null(customer, nameof(customer));
var customerToUpdate = mapper.Map <ApiClients.CustomerApi.Models.UpdateCustomer.Customer>(customer);
Guard.Against.Null(customerToUpdate, nameof(customerToUpdate));
var newAddress = mapper.Map <ApiClients.CustomerApi.Models.UpdateCustomer.CustomerAddress>(viewModel.CustomerAddress);
Guard.Against.Null(newAddress, nameof(newAddress));
customerToUpdate.Addresses.Add(newAddress);
logger.LogInformation("Updating customer {@Customer}", customer);
await customerApiClient.UpdateCustomerAsync(viewModel.AccountNumber, customerToUpdate);
logger.LogInformation("Customer updated successfully");
}
public ActionResult Save(EditCustomerAddressViewModel model, string command)
{
if (command.ToLower() == "save")
{
var modelError = CustomerService.InsertOrUpdateCustomerAddress(model.CustomerAddress, model.LGS);
if (modelError.IsError)
{
prepareEditModel(model, model.CurrentCompany.Id, model.CustomerAddress.CustomerId.Value);
model.SetErrorOnField(ErrorIcon.Error,
modelError.Message,
"CustomerAddress_" + modelError.FieldName);
return(View("Edit", model));
}
else
{
return(RedirectToAction("CustomerAddresses", new { id = model.ParentId }));
}
}
else
{
return(RedirectToAction("CustomerAddresses", new { id = model.ParentId }));
}
}