public async void Submit_New_Invalid_InitiationForm_MissingItems(FormDetailModel form)
{
var mockFormService = new Mock <IFormService>();
mockFormService.Setup(x => x.SubmitCustomerForm(It.IsAny <CustomerForm>())).ReturnsAsync(1);
IMapper mapper = TestUtilities.GetMapper(new CustomerProfile(), new FormProfile(), new InstitutionProfile());
FormManager manager = new FormManager(_logger, mapper, mockFormService.Object, Mock.Of <IItemService>(), Mock.Of <IIsotopeOrderingAuthorizationService>(), Mock.Of <ICustomerService>(), _eventService, Mock.Of <INotificationManager>());
List <FormInitiationItemModel> items = new List <FormInitiationItemModel>();
AddressDetailModel address = new Fixture().Create <AddressDetailModel>();
address.State = "MO";
address.ZipCode = "12345";
form.InitiationModel = new FormInitiationDetailModel()
{
Institution = new InstitutionDetailModel()
{
Id = 1
},
ShippingAddress = address,
Items = items
};
ApplicationResult result = await manager.SubmitInitiationForm(form);
_output.WriteLine(result.Message);
CustomAssertions.AssertValidationErrorsExist(result);
}
public async Task <ApplicationResult> SubmitInitiationForm(FormDetailModel form)
{
var validator = new FormDetailModelValidator();
ValidationResult result = await validator.ValidateAsync(form);
if (result.IsValid)
{
if (form.Action == CustomerFormStatus.Approved)
{
return(await ApproveInitiationForm(form.CustomerDetailFormId, form.InitiationModel !.AdminSignature));
}
if (form.Action == CustomerFormStatus.Denied)
{
return(await DenyInitiationForm(form.Customer.Id, form.CustomerDetailFormId));
}
if (form.Action == CustomerFormStatus.AwaitingCustomerSupervisorApproval)
{
CustomerForm customerForm = _mapper.Map <CustomerForm>(form);
int customerFormId = await _service.SubmitCustomerForm(customerForm);
await _eventService.CreateEvent(EntityEventType.Customer, form.Customer.Id, Events.Customer.SubmittedInitiationForm);
await UpdateFormStatus(form.Customer.Id, customerFormId, form.Action);
await _notificationManager.ProcessExternalMtaNotification(form);
}
return(ApplicationResult.Success("Form submitted", form.CustomerDetailFormId));
}
return(ApplicationResult.Error(result));
}
public async Task <bool> ProcessExternalMtaNotification(FormDetailModel form)
{
NotificationConfiguration notificationConfiguration = await _service.GetExternalMtaNotificationConfiguration();
NotificationDto notificationDto = new NotificationDto(notificationConfiguration.Title);
RecipientDto recipientDto = new RecipientDto()
{
EmailAddress = form.InitiationModel !.CustomerAdminSignature.Email,
Name = form.InitiationModel !.CustomerAdminSignature.PrintedName
};
notificationDto.AddRecipient(recipientDto);
try {
ExternalMtaNotification notificationModel = new ExternalMtaNotification(_settings.CurrentValue.BaseUrl, form);
notificationDto.Body = _templateManager.GetContent(notificationConfiguration.Target, notificationConfiguration.TemplatePath, notificationModel).Result;
int processedCount = await _service.CreateNotifications(notificationDto.ToNotifications());
if (processedCount > 0)
{
await _service.UpdateLastProcessedDate(notificationConfiguration.Id);
return(true);
}
}
catch (Exception ex) {
_logger.LogError(ex, "Failed to process notification configuration {notificationConfiguration}", notificationConfiguration);
}
return(false);
}
public async Task <FormDetailModel> GetInitiationForm(CustomerItemModel customer)
{
FormDetailModel formDetailModel = await _service.Get <FormDetailModel>(FormType.Initiation);
formDetailModel.InitiationModel = new FormInitiationDetailModel();
formDetailModel.InitiationModel.Items = await _itemService.GetList <FormInitiationItemModel>();
formDetailModel.Customer = customer;
return(formDetailModel);
}
public async Task <IActionResult> InitiationForm(FormDetailModel model)
{
if (ModelState.IsValid)
{
ApplicationResult result = await _formManager.SubmitInitiationForm(model);
SetApplicationResult(result);
return(RedirectToAction(nameof(HomeController.Index), "Home"));
}
return(View(model));
}
public async void Get_Form_From_Type(Form form)
{
form.Type = FormType.Initiation;
string instanceName = Guid.NewGuid().ToString();
using (var context = TestUtilities.GetDbContext(instanceName)) {
context.Forms.Add(form);
await context.SaveChangesAsync();
}
using (var context = TestUtilities.GetDbContext(instanceName)) {
FormService service = new FormService(context, TestUtilities.GetMapper());
FormDetailModel model = await service.Get <FormDetailModel>(FormType.Initiation);
Assert.NotNull(model);
}
}
public async void Submit_Valid_InitiationForm(FormDetailModel form)
{
var mockFormService = new Mock <IFormService>();
mockFormService.Setup(x => x.SubmitCustomerForm(It.IsAny <CustomerForm>())).ReturnsAsync(1);
IMapper mapper = TestUtilities.GetMapper(new CustomerProfile(), new FormProfile(), new InstitutionProfile());
FormManager manager = new FormManager(_logger, mapper, mockFormService.Object, Mock.Of <IItemService>(), Mock.Of <IIsotopeOrderingAuthorizationService>(), Mock.Of <ICustomerService>(), _eventService, Mock.Of <INotificationManager>());
List <FormInitiationItemModel> items = new List <FormInitiationItemModel>()
{
new FormInitiationItemModel()
{
IsSelected = true
}
};
Fixture fixture = new Fixture();
AddressDetailModel address = fixture.Create <AddressDetailModel>();
address.State = "MO";
address.ZipCode = "12345";
ContactDetailModel contact = fixture.Create <ContactDetailModel>();
contact.Email = "*****@*****.**";
contact.PhoneNumber = "123-123-1234";
form.InitiationModel = new FormInitiationDetailModel()
{
Institution = new InstitutionDetailModel()
{
Name = "Test",
Address = address,
FinancialContact = contact,
SafetyContact = contact
},
ShippingAddress = address,
Items = items
};
form.CustomerDetailFormId = 1;
form.InitiationModel.CustomerAdminSignature.Email = "*****@*****.**";
form.InitiationModel.CustomerAdminSignature.PhoneNumber = "123-123-1234";
ApplicationResult result = await manager.SubmitInitiationForm(form);
_output.WriteLine(result.Message);
CustomAssertions.AssertValidationErrorsDoNotExist(result);
}
private async Task UpdateCustomerFromInitiationForm(FormDetailModel form)
{
CustomerDetailModel customerModel = await _customerService.Get <CustomerDetailModel>(form.Customer.Id);
FormInitiationDetailModel initiationModel = form.InitiationModel !;
customerModel.Institutions.Add(new CustomerInstitutionDetailModel()
{
Institution = initiationModel.Institution,
Relationship = CustomerInstitutionRelationship.Primary
});
customerModel.Addresses.Add(new CustomerAddressDetailModel()
{
Address = initiationModel.ShippingAddress,
Type = AddressType.Shipping
});
customerModel.Addresses.Add(new CustomerAddressDetailModel()
{
Address = initiationModel.ShippingAddress,
Type = AddressType.Billing
});
customerModel.Status = CustomerStatus.Initiated;
foreach (FormInitiationItemModel item in initiationModel.Items.Where(x => x.IsSelected))
{
customerModel.ItemConfigurations.Add(new ItemConfigurationDetailModel()
{
ItemId = item.Item.Id,
MinimumAmount = item.Item.DefaultMinQuantity,
MaximumAmount = item.Item.DefaultMaxQuantity,
Price = item.Item.DefaultPrice.GetValueOrDefault(0)
});
}
customerModel.Contact = initiationModel.Contact;
Customer customer = _mapper.Map <Customer>(customerModel);
await _customerService.Update(customer);
}
public ExternalMtaNotification(string baseUrl, FormDetailModel form)
{
Form = form;
FormUrl = baseUrl + $"Form/InitiationForm/{form.InitiationModel!.CustomerAdminSignature.Email}/{form.FormIdentifier}";
}
public async Task <IActionResult> InitiationForm(string supervisorEmailAddress, Guid formIdentifier, FormDetailModel model)
{
if (ModelState.IsValid)
{
ApplicationResult result = await _formManager.SubmitInitiationFormSignature(supervisorEmailAddress, formIdentifier, model.InitiationModel !.CustomerAdminSignature);
SetApplicationResult(result);
return(RedirectToAction(nameof(HomeController.Confirmation), "Home"));
}
model.AllowSignatureFromCustomerAdmin = true;
return(View(model));
}
