private PartialViewResult GetLicenseTable(AppraiserUserLicensesViewModel licenseList)
{
ViewBag.Header = licenseList.SectionTitle;
ViewBag.IsOwnPage = licenseList.IsOwnPage;
ViewBag.CurrentStep = NameHelper.AppraiserProfile.License;
ViewBag.Area = "Appraiser";
ViewBag.CurrentControllerName = NameHelper.AppraiserProfile.Controller;
return PartialView("Tables/AppraiserLicense", licenseList);
}
public ActionResult License(AppraiserUserLicensesViewModel viewModel, string nextStep, int? userId = null)
{
if (viewModel.EditUserId == 0)
{
viewModel.EditUserId = userId.HasValue ? userId.Value : 0;
}
if (viewModel.EnO.ProviderType != (int)EnOProviderType.Other)
{
ModelState.Remove("EnO.ProviderTypeOtherName.ProviderTypeOtherName");
}
if (ModelState.IsValid)
{
ModelState.Clear();
_appraiserUserService.SaveEOInsurance(User.Identity.Name, viewModel.EditUserId, viewModel.EnO);
CommitProviderInstance.Commit();
var itemToValidate = viewModel.Licenses.LicenseItems.SingleOrDefault(e => e.IsEditable);
if (itemToValidate != null)
{
IsLicenseValid(itemToValidate, viewModel);
if (!viewModel.Licenses.LicenseItems.Any(e => e.Status == LicenseStatus.Rejected))
{
_appraiserUserService.SaveLicenseItem(User.Identity.Name, viewModel.EditUserId, itemToValidate);
CommitProviderInstance.Commit();
itemToValidate.IsEditable = false;
}
else
{
return GetLicenseView(viewModel, viewModel.EditUserId);
}
}
if (SecurityContext.CurrentUser.HasUserAnyRoles(RoleType.Appraiser, RoleType.AppraisalCompanyAdmin, RoleType.CompanyAdminAndAppraiser, RoleType.DvsAdmin, RoleType.DvsSuperAdmin)
&& !_appraiserUserService.HasAppraiserValidLicense(User.Identity.Name, userId))
{
viewModel.AlertMessage = Constants.ErrorMessages.LicensesNoActive;
return GetLicenseView(viewModel, viewModel.EditUserId);
}
return RedirectToStep(nextStep, viewModel.EditUserId, viewModel.IsOwnPage);
}
TempData[_appraiserLicenseKey] = viewModel;
return RedirectToStep(NameHelper.AppraiserProfile.License, viewModel.EditUserId, viewModel.IsOwnPage);
}
public void AppraiserWizard_IsLicenseValid_should_set_IsEditable_true_if_license_state_is_Rejected()
{
string itemToEditID = Guid.NewGuid().ToString();
var model = new AppraiserUserLicensesViewModel();
LicenseItemViewModel itemToSave = new LicenseItemViewModel() { Id = itemToEditID };
itemToSave.Number = "testNumber";
itemToSave.Status = LicenseStatus.Active;
DateTime? outDatetime;
int? outLicenseType;
AscGovLicenseService.ValidateLicense(Arg.Any<string>(), Arg.Any<string>(), out outDatetime, out outLicenseType).Returns(LicenseStatus.Rejected);
model.Licenses.LicenseItems.Add(itemToSave);
//act
var act = Target.LicenseSave(model, itemToEditID);
//assert
itemToSave.IsEditable.Should().BeTrue();
}
private ActionResult GetLicenseView(AppraiserUserLicensesViewModel licenseList, int? userId)
{
ViewBag.Header = licenseList.SectionTitle;
ViewBag.IsOwnPage = licenseList.IsOwnPage;
ViewBag.CurrentStep = NameHelper.AppraiserProfile.License;
ViewBag.Area = "Appraiser";
ViewBag.CurrentControllerName = NameHelper.AppraiserProfile.Controller;
return View(NameHelper.AppraiserProfile.License, GetViewModel(licenseList, userId));
}
private bool IsLicenseValid(LicenseItemViewModel license, AppraiserUserLicensesViewModel viewModel)
{
DateTime? expirationDate;
int? licenseType;
license.Status = _ascGovLicenseService.ValidateLicense(license.Number, license.StateId, out expirationDate, out licenseType);
var result = _hudService.CheckFHARoster(license.Number);
license.CHUMSId = result.CHUMSId;
license.FHARoster = result.FHARoster;
if (license.Status == LicenseStatus.Rejected)
{
license.AlertMessage = Constants.ErrorMessages.LicenseInvalid;
}
if (_appraiserUserService.IsLicenseUniqForUser(User.Identity.Name, viewModel.EditUserId, license))
{
license.Status = LicenseStatus.Rejected;
license.AlertMessage = Constants.ErrorMessages.LicenseDuplicate;
}
license.IsEditable = (license.Status == LicenseStatus.Rejected);
license.ExpirationDate = expirationDate;
if (licenseType.HasValue)
license.LicenseType = SafeConvert.ToEnum<LicenseType>(licenseType).Value;
return string.IsNullOrEmpty(license.AlertMessage);
}
private ActionResult GetLicenseView(AppraiserUserLicensesViewModel model)
{
ViewBag.CurrentStep = (int)TabIndex.License;
return View(NameHelper.AppraiserWizard.License, GetWrappedViewModel(model));
}
public void AppraiserWizard_License_Edit_should_change_status_for_edit_item()
{
string itemToEditID = Guid.NewGuid().ToString();
var model = new AppraiserUserLicensesViewModel();
LicenseItemViewModel itemToEdit = new LicenseItemViewModel() { Id = itemToEditID };
DateTime? outDatetime;
int? outLicenseType;
AscGovLicenseService.ValidateLicense(Arg.Any<string>(), Arg.Any<string>(), out outDatetime, out outLicenseType).Returns(LicenseStatus.Rejected);
model.Licenses.LicenseItems.Add(itemToEdit);
//act
var act = Target.LicenseEdit(model, itemToEditID);
//assert
itemToEdit.IsEditable.Should().BeTrue();
}
public ActionResult LicenseCancel(AppraiserUserLicensesViewModel viewModel, string LicenseCancel)
{
ModelState.Clear();
viewModel = _appraiserUserService.GetAppraiserLicenses(User.Identity.Name, viewModel.EditUserId);
return GetLicenseTable(viewModel);
}
public void AppraiserWizard_License_no_items_post_should_show_warning_message()
{
var model = new AppraiserUserLicensesViewModel();
AppraiserUserService.GetAppraiserSignUpLastStep(Arg.Any<string>()).Returns(1);
AppraiserUserService.GetAppraiserLicenses(Arg.Any<string>()).Returns(model);
AppraiserUserService.GetAppraiser(Arg.Any<string>(), Arg.Any<int?>()).Returns(new AppraiserUser());
var actionResult = Target.License(model, 2);
Assert.AreEqual(Target.ViewBag.LastCompleteMenuIndex, 1);
Target.TempData.Should().HaveCount(0);
model.AlertMessage.Should().NotBeNull();
actionResult.Should().NotBeNull().And.BeOfType<ViewResult>();
((ViewResult)actionResult).ViewName.Should().Be("License");
((ViewResult)actionResult).Model.Should().NotBeNull().And.BeOfType<AppraiserDetailsViewModel>();
((AppraiserDetailsViewModel)((ViewResult)actionResult).Model).TabStep.Should().NotBeNull().And.BeOfType<AppraiserUserLicensesViewModel>();
}
public void AppraiserWizard_License_Edit_should_validate_current_editing_item()
{
string itemToEditID = Guid.NewGuid().ToString();
var model = new AppraiserUserLicensesViewModel();
LicenseItemViewModel editingItem = new LicenseItemViewModel();
LicenseItemViewModel itemToEdit = new LicenseItemViewModel() { Id = itemToEditID };
editingItem.IsEditable = true;
editingItem.Number = "testNumber";
editingItem.Status = LicenseStatus.Active;
DateTime? outDatetime;
int? outLicenseType;
AscGovLicenseService.ValidateLicense(Arg.Any<string>(), Arg.Any<string>(), out outDatetime, out outLicenseType).Returns(LicenseStatus.Rejected);
model.Licenses.LicenseItems.Add(editingItem);
model.Licenses.LicenseItems.Add(itemToEdit);
//act
var act = Target.LicenseEdit(model, itemToEditID);
//assert
editingItem.Status.Should().NotBe(LicenseStatus.Active);
}
public void AppraiserWizard_License_valid_model_post_should_redirect_to_license_without_model()
{
AppraiserUserService.GetAppraiserSignUpLastStep(Arg.Any<string>()).Returns(1);
var model = new AppraiserUserLicensesViewModel();
model.Licenses.LicenseItems.Add(new LicenseItemViewModel() { State = "GU", Number = "LA-09-030", Status = LicenseStatus.Active });
var actionResult = Target.License(model, null);
Target.TempData.Should().HaveCount(1);
Target.TempData["SaveDraft"].Should().Be(true);
model.AlertMessage.Should().BeNull();
actionResult.Should().NotBeNull().And.BeOfType<RedirectToRouteResult>();
((RedirectToRouteResult)actionResult).RouteValues.Should().HaveCount(1);
((RedirectToRouteResult)actionResult).RouteValues["action"].Should().Be("License");
}
public void AppraiserWizard_License_invalid_model_post_should_redirect_to_license_with_model()
{
Target.ModelState.AddModelError("test error", "test error");
var model = new AppraiserUserLicensesViewModel();
var actionResult = Target.License(model, null);
Target.TempData.Should().HaveCount(1);
actionResult.Should().NotBeNull().And.BeOfType<RedirectToRouteResult>();
((RedirectToRouteResult)actionResult).RouteValues.Should().HaveCount(1);
((RedirectToRouteResult)actionResult).RouteValues["action"].Should().Be("License");
}
private PartialViewResult GetLicenseTable(AppraiserUserLicensesViewModel model)
{
ViewBag.CurrentStep = (int)TabIndex.License;
ViewBag.Area = "SignUp";
ViewBag.CurrentControllerName = NameHelper.AppraiserWizard.Controller;
foreach (var item in model.Licenses.LicenseItems)
{
if (item.Status != LicenseStatus.Rejected && item.State != null && item.State.Length == 2)
{
item.State = _referenceManagement.GetAllStates()[item.StateId];
}
}
return PartialView("Tables/AppraiserLicense", model);
}
public ActionResult LicenseAdd(AppraiserUserLicensesViewModel viewModel)
{
if (ValidateLicenseModel())
{
ModelState.Clear();
var itemToValidate = viewModel.Licenses.LicenseItems.SingleOrDefault(e => e.IsEditable);
if (itemToValidate != null)
{
IsLicenseValid(itemToValidate, viewModel);
}
if (!viewModel.Licenses.LicenseItems.Any(e => e.Status == LicenseStatus.Rejected))
{
if (itemToValidate != null)
{
ViewBag.NotificationMessage = itemToValidate.IsNew ? Constants.Notifications.LicenseSaved : Constants.Notifications.LicenseUpdated;
_appraiserUserService.SaveLicenseItem(User.Identity.Name, viewModel.EditUserId, itemToValidate);
CommitProviderInstance.Commit();
}
viewModel.Licenses.LicenseItems.Add(new LicenseItemViewModel() { Id = Guid.NewGuid().ToString(), IsEditable = true, File = new LicenseItemFileViewModel() });
}
}
return GetLicenseTable(viewModel);
}
public void AppraiserWizard_License_Save_should_throw_exception_if_id_is_empty()
{
var model = new AppraiserUserLicensesViewModel();
//act
Action act = () => Target.LicenseSave(model, "");
//assert
act.ShouldThrow<ApplicationException>().And.Message.Should().Contain("license"); ;
}
public ActionResult LicenseSave(AppraiserUserLicensesViewModel viewModel, string LicenseSave)
{
if (ValidateLicenseModel())
{
ModelState.Clear();
var newItem = viewModel.Licenses.LicenseItems.SingleOrDefault(e => e.Id == LicenseSave);
if (newItem == null)
{
throw new ApplicationException("license not found");
}
if (IsLicenseValid(newItem, viewModel))
{
ViewBag.NotificationMessage = newItem.IsNew ? Constants.Notifications.LicenseSaved : Constants.Notifications.LicenseUpdated;
_appraiserUserService.SaveLicenseItem(User.Identity.Name, viewModel.EditUserId, newItem);
CommitProviderInstance.Commit();
viewModel = _appraiserUserService.GetAppraiserLicenses(User.Identity.Name, viewModel.EditUserId);
}
}
return GetLicenseTable(viewModel);
}
public void AppraiserWizard_License_Save_should_populate_notification_license_updated_to_viewBag_if_new_item_saved()
{
string itemToEditID = "123";
var model = new AppraiserUserLicensesViewModel();
LicenseItemViewModel itemToSave = new LicenseItemViewModel() { Id = itemToEditID };
itemToSave.Number = "testNumber";
itemToSave.Status = LicenseStatus.Expired;
DateTime? outDatetime;
int? outLicenseType;
AscGovLicenseService.ValidateLicense(Arg.Any<string>(), Arg.Any<string>(), out outDatetime, out outLicenseType).Returns(LicenseStatus.Active);
AppraiserUserService.IsLicenseUniqForUser(Arg.Any<string>(), Arg.Any<int?>(), Arg.Any<LicenseItemViewModel>()).Returns(false);
AppraiserUserService.GetAppraiserLicenses(Arg.Any<string>(), Arg.Any<int?>()).Returns(model);
model.Licenses.LicenseItems.Add(itemToSave);
//act
var act = Target.LicenseSave(model, itemToEditID);
//assert
itemToSave.Status.Should().NotBe(LicenseStatus.Expired);
string notificationMessage = Target.ViewBag.NotificationMessage;
notificationMessage.Should().NotBeNullOrEmpty();
notificationMessage.Should().BeEquivalentTo(Constants.Notifications.LicenseUpdated);
}
public ActionResult LicenseDel(AppraiserUserLicensesViewModel viewModel, string LicenseDel)
{
if (ValidateLicenseModel())
{
ModelState.Clear();
var item = viewModel.Licenses.LicenseItems.SingleOrDefault(e => e.Id == LicenseDel);
if (item == null)
{
throw new ApplicationException("license not found");
}
var itemToValidate = viewModel.Licenses.LicenseItems.SingleOrDefault(e => e.IsEditable);
if (itemToValidate != null)
{
IsLicenseValid(itemToValidate, viewModel);
}
if (!viewModel.Licenses.LicenseItems.Any(e => e.Status == LicenseStatus.Rejected))
{
if (itemToValidate != null)
{
_appraiserUserService.SaveLicenseItem(User.Identity.Name, viewModel.EditUserId, itemToValidate);
}
ViewBag.NotificationMessage = Constants.Notifications.LicenseDeleted;
_appraiserUserService.DeleteLicenseItem(User.Identity.Name, viewModel.EditUserId, LicenseDel);
CommitProviderInstance.Commit();
viewModel = _appraiserUserService.GetAppraiserLicenses(User.Identity.Name, viewModel.EditUserId);
}
}
return GetLicenseTable(viewModel);
}
public void AppraiserWizard_IsLicenseValid_should_populate_alert_message_if_license_not_uniq_for_user()
{
string itemToEditID = Guid.NewGuid().ToString();
var model = new AppraiserUserLicensesViewModel();
LicenseItemViewModel itemToSave = new LicenseItemViewModel() { Id = itemToEditID };
itemToSave.IsEditable = true;
itemToSave.Number = "testNumber";
itemToSave.Status = LicenseStatus.Active;
DateTime? outDatetime;
int? outLicenseType;
AscGovLicenseService.ValidateLicense(Arg.Any<string>(), Arg.Any<string>(), out outDatetime, out outLicenseType).Returns(LicenseStatus.Expired);
AppraiserUserService.IsLicenseUniqForUser(Arg.Any<string>(), Arg.Any<int?>(), Arg.Any<LicenseItemViewModel>()).Returns(true);
model.Licenses.LicenseItems.Add(itemToSave);
//act
var act = Target.LicenseSave(model, itemToEditID);
//assert
itemToSave.Status.Should().Be(LicenseStatus.Rejected);
itemToSave.AlertMessage.Should().NotBeNullOrEmpty().And.Contain("Specified license");
}
private bool ValidateEditedLicense(AppraiserUserLicensesViewModel model)
{
ModelState.Clear();
var editedItem = model.Licenses.LicenseItems.SingleOrDefault(e => e.IsEditable);
if (editedItem != null)
{
IsLicenseValid(editedItem, model);
}
return editedItem == null || editedItem.Status != LicenseStatus.Rejected;
}
public ActionResult License(AppraiserUserLicensesViewModel viewModel, int? nextStep)
{
if (viewModel.EnO.ProviderType != (int)EnOProviderType.Other)
{
ModelState.Remove("EnO.ProviderTypeOtherName.ProviderTypeOtherName");
}
if ((nextStep ?? (int)TabIndex.License) <= (int)TabIndex.License || ModelState.IsValid)
{
ViewBag.Area = "SignUp";
ViewBag.CurrentControllerName = NameHelper.AppraiserWizard.Controller;
_appraiserUserService.SaveEOInsurance(User.Identity.Name, viewModel.EditUserId, viewModel.EnO);
CommitProviderInstance.Commit();
var itemToValidate = viewModel.Licenses.LicenseItems.SingleOrDefault(e => e.IsEditable);
if (itemToValidate != null)
{
IsLicenseValid(itemToValidate, viewModel);
if (!viewModel.Licenses.LicenseItems.Any(e => e.Status == LicenseStatus.Rejected))
{
_appraiserUserService.SaveLicenseItem(User.Identity.Name, null, itemToValidate);
CommitProviderInstance.Commit();
itemToValidate.IsEditable = false;
}
else
{
return GetLicenseView(viewModel);
}
}
if (!_appraiserUserService.HasAppraiserValidLicense(User.Identity.Name) && nextStep > (int)TabIndex.License)
{
viewModel = _appraiserUserService.GetAppraiserLicenses(User.Identity.Name);
viewModel.AlertMessage = Constants.ErrorMessages.LicensesNoActive;
ViewBag.LastCompleteMenuIndex = _appraiserUserService.GetAppraiserSignUpLastStep(User.Identity.Name);
return GetLicenseView(viewModel);
}
SaveLastCompletedStep(TabIndex.License, nextStep);
CommitProviderInstance.Commit();
if (!nextStep.HasValue || nextStep.Value == (int)TabIndex.License)
{
TempData["SaveDraft"] = true;
}
ViewBag.NotificationMessage = null;
return RedirectToStep(SafeConvert.ToEnum<TabIndex>(nextStep) ?? TabIndex.License);
}
TempData[_appraiserLicensesKey] = viewModel;
return RedirectToStep(TabIndex.License);
}
