public async Task UpdateContact(EditCustomerContactViewModel viewModel)
{
logger.LogInformation("UpdateContact called");
logger.LogInformation("Getting customer for {AccountNumber}", viewModel.AccountNumber);
var customer = await customerApiClient.GetCustomerAsync <ApiClients.CustomerApi.Models.GetCustomer.StoreCustomer>(
viewModel.AccountNumber
);
logger.LogInformation("Retrieved customer {@Customer}", customer);
Guard.Against.Null(customer, nameof(customer));
var customerToUpdate = mapper.Map <ApiClients.CustomerApi.Models.UpdateCustomer.StoreCustomer>(customer);
Guard.Against.Null(customerToUpdate, nameof(customerToUpdate));
var contact = customerToUpdate.Contacts.FirstOrDefault(c => c.ContactType == viewModel.CustomerContact.ContactType);
Guard.Against.Null(contact, nameof(contact));
mapper.Map(viewModel.CustomerContact.ContactPerson, contact.ContactPerson);
logger.LogInformation("Updating customer {@Customer}", customer);
await customerApiClient.UpdateCustomerAsync(viewModel.AccountNumber, customerToUpdate);
logger.LogInformation("Customer updated successfully");
}
public async Task EditContactPost_ValidModelState_ReturnsRedirect(
[Frozen] Mock <ICustomerService> customerService,
EditCustomerContactViewModel viewModel,
[Greedy] CustomerController sut
)
{
//Arrange
var mockCustomerService = new Mock <ICustomerService>();
//Act
var actionResult = await sut.EditContact(viewModel);
//Assert
customerService.Verify(x => x.UpdateContact(
It.IsAny <EditCustomerContactViewModel>()
));
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 AddContact(EditCustomerContactViewModel viewModel)
{
logger.LogInformation("AddContact called");
logger.LogInformation("Getting customer for {AccountNumber}", viewModel.AccountNumber);
var customer = await customerApiClient.GetCustomerAsync <ApiClients.CustomerApi.Models.GetCustomer.StoreCustomer>(
viewModel.AccountNumber
);
logger.LogInformation("Retrieved customer {@Customer}", customer);
Guard.Against.Null(customer, nameof(customer));
var customerToUpdate = mapper.Map <ApiClients.CustomerApi.Models.UpdateCustomer.StoreCustomer>(customer);
Guard.Against.Null(customerToUpdate, nameof(customerToUpdate));
var contactToAdd = mapper.Map <ApiClients.CustomerApi.Models.UpdateCustomer.StoreCustomerContact>(
viewModel.CustomerContact
);
customerToUpdate.Contacts.Add(contactToAdd);
logger.LogInformation("Updating customer {@Customer}", customer);
await customerApiClient.UpdateCustomerAsync(viewModel.AccountNumber, customerToUpdate);
logger.LogInformation("Customer updated successfully");
}
public async Task EditContactGet_ReturnsViewModel(
[Frozen] Mock <ICustomerService> customerService,
EditCustomerContactViewModel viewModel,
[Greedy] CustomerController sut
)
{
//Arrange
customerService.Setup(x => x.GetCustomerContact(
It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()
))
.ReturnsAsync(viewModel);
//Act
var actionResult = await sut.EditContact(
viewModel.AccountNumber,
viewModel.CustomerContact.ContactPerson.FullName(),
viewModel.CustomerContact.ContactType
);
//Assert
var viewResult = actionResult.Should().BeAssignableTo <ViewResult>().Subject;
viewResult.Model.Should().BeAssignableTo <EditCustomerContactViewModel>();
customerService.Verify(x => x.GetCustomerContact(
It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>())
);
}
public async Task AddContact_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>();
mockReferenceDataApi.Setup(x => x.GetContactTypesAsync())
.ReturnsAsync(new List <referenceDataApi.Models.GetContactTypes.ContactType>
{
new referenceDataApi.Models.GetContactTypes.ContactType {
Name = "Owner"
},
new referenceDataApi.Models.GetContactTypes.ContactType {
Name = "Marketing Assistant"
},
new referenceDataApi.Models.GetContactTypes.ContactType {
Name = "Order Administrator"
}
});
mockCustomerApi
.Setup(x => x.GetCustomerAsync <customerApi.Models.GetCustomer.StoreCustomer>(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 EditCustomerContactViewModel
{
CustomerContact = new CustomerContactViewModel
{
ContactType = "Owner",
ContactPerson = new PersonViewModel
{
FirstName = "Orlando",
MiddleName = "N.",
LastName = "Gee"
}
}
};
await svc.AddContact(viewModel);
//Assert
mockCustomerApi.Verify(x => x.UpdateCustomerAsync(
It.IsAny <string>(),
It.IsAny <customerApi.Models.UpdateCustomer.Customer>()
));
}
public async Task <IActionResult> EditContact(EditCustomerContactViewModel viewModel)
{
if (ModelState.IsValid)
{
await customerService.UpdateContact(viewModel);
return(RedirectToAction("Detail", new { viewModel.AccountNumber }));
}
return(View(viewModel));
}
public ActionResult Edit(int id, int customerId)
{
var model = new EditCustomerContactViewModel();
prepareEditModel(model, id, customerId);
model.CustomerContact = CustomerService.FindCustomerContactModel(id, model.CurrentCompany, customerId);
model.LGS = CustomerService.LockCustomerContact(model.CustomerContact);
return(View(model));
}
void prepareEditModel(EditCustomerContactViewModel model, int id, int customerId)
{
var customer = CustomerService.FindCustomerModel(customerId, CurrentCompany);
string title = EvolutionResources.bnrAddEditCustomerContact + (customer == null ? "" : " - " + customer.Name);
if (id <= 0)
{
title += " - " + EvolutionResources.lblNewContact;
}
PrepareViewModel(model, title, customerId, MakeMenuOptionFlags(customerId, 0));
model.SalutationList = LookupService.FindLOVItemsListItemModel(null, LOVName.Salutation);
model.ParentId = customerId;
}
public async Task EditContactPost_InvalidModelState_ReturnsViewModel(
EditCustomerContactViewModel viewModel,
[Greedy] CustomerController sut
)
{
//Arrange
sut.ModelState.AddModelError("AccountNumber", viewModel.AccountNumber);
//Act
var actionResult = await sut.EditContact(viewModel);
//Assert
var viewResult = actionResult.Should().BeAssignableTo <ViewResult>().Subject;
viewResult.Model.Should().Be(viewModel);
}
public async Task <EditCustomerContactViewModel> AddContact(string accountNumber, string customerName)
{
logger.LogInformation("AddContact called");
var vm = new EditCustomerContactViewModel
{
IsNewContact = true,
AccountNumber = accountNumber,
CustomerName = customerName,
CustomerContact = new CustomerContactViewModel
{
ContactPerson = new PersonViewModel
{
}
},
ContactTypes = await GetContactTypes()
};
return(vm);
}
public async Task <EditCustomerContactViewModel> GetCustomerContact(string accountNumber, string contactName, string contactType)
{
logger.LogInformation("GetCustomerContact called");
var customer = await customerApiClient
.GetCustomerAsync <ApiClients.CustomerApi.Models.GetCustomer.StoreCustomer>(accountNumber);
var contact = customer.Contacts.FirstOrDefault(c =>
c.ContactType == contactType &&
c.ContactPerson.FullName() == contactName
);
var vm = new EditCustomerContactViewModel
{
IsNewContact = false,
AccountNumber = accountNumber,
CustomerName = customer.Name,
CustomerContact = mapper.Map <CustomerContactViewModel>(contact),
ContactTypes = await GetContactTypes()
};
return(vm);
}
public ActionResult Save(EditCustomerContactViewModel model, string command)
{
if (command.ToLower() == "save")
{
var modelError = CustomerService.InsertOrUpdateCustomerContact(model.CustomerContact, CurrentUser, model.LGS);
if (modelError.IsError)
{
prepareEditModel(model, model.CurrentCompany.Id, model.CustomerContact.CustomerId.Value);
model.SetErrorOnField(ErrorIcon.Error,
modelError.Message,
"CustomerContact_" + modelError.FieldName);
return(View("Edit", model));
}
else
{
return(RedirectToAction("CustomerContacts", new { id = model.ParentId }));
}
}
else
{
return(RedirectToAction("CustomerContacts", new { id = model.ParentId }));
}
}
