private void InitCurrentUser(User user, AppraiserUser appraiserUser)
{
appraiserUser.User = user;
SecurityContext.CurrentUser.Returns(user);
CurrentAppraiser.CurrentAppraiser.Returns(appraiserUser);
}
public void CreateCompanyWithAppraisalCompanyAdminUser(AppraisalCompanySignUpViewModel viewModel, AddressViewModel companyAddressModel)
{
AppraisalCompanyProfileViewModel companyViewModel = new AppraisalCompanyProfileViewModel();
companyViewModel.CompanyName = viewModel.CompanyName;
companyViewModel.CompanyType = viewModel.CompanyType.HasValue && viewModel.CompanyType.Value != 0 ? viewModel.CompanyType : null;
var dbCompany = _appraisalCompanyManagement.CreateAppraisalCompany(companyViewModel);
dbCompany.Contact = new AppraisalCompanyContact();
if (companyAddressModel != null)
{
dbCompany.Contact.PhysicalAddress = new Address()
{
City = companyAddressModel.City,
State = companyAddressModel.State.Substring(0,2),
Street = companyAddressModel.Street,
Street2 = companyAddressModel.Street2,
ZIP = companyAddressModel.ZIP,
};
}
else
{
dbCompany.Contact.PhysicalAddress = new Address() { State = viewModel.LocationState.Substring(0, 2) };
}
var user = _usersManagement.CreateUser(viewModel.AppraisalCompanyAdmin, RoleType.CompanyAdminAndAppraiser);
AppraiserUser appraiserUser = new AppraiserUser();
appraiserUser.Company = dbCompany;
appraiserUser.User = user;
appraiserUser.Status = AppraiserUserStatus.Applied;
_appraisalCompanyAdminManagement.CreateUser(appraiserUser);
}
public void GetReadyForDisbursementOrders_should_return_order()
{
var appraiser = new AppraiserUser
{
BankingInfo = new AppraiserBanking
{
AccountNumber = "Account Number",
AccountType = AccountType.Savings,
RoutingNumber = "Routing Number",
BankingInstitution = "test Banking Institution",
BankAddress = new Address { City = "City", State = "State", ZIP = "Zip" }
},
};
var order = new Order { CompletionDate = new DateTime(2012, 08, 20), AcceptedAppraiserUser = appraiser };
var expected = new List<Order> { order };
var date = new DateTime(2012, 08, 20);
var status = OrderStatus.Completed.ToString();
var needDate = date.AddDays(1).AddMinutes(-1);
var where = PredicateBuilder.True<Order>();
where = where.AndAlso(o => o.OrderStatusId == status)
.AndAlso(o => o.CompletionDate < needDate);
_orderRepository.Get(where).Returns(expected);
var actual = _feeDisbursementManager.GetReadyForDisbursementOrders("08/20/2012");
actual.Should().Equals(expected);
}
public void AppraiserOrderDeliveryServiceTest_SendOrderInvitations()
{
//arrange
var appraiser = new AppraiserUser
{
Status = AppraiserUserStatus.Active,
User = new User { Id = 1, Email = "*****@*****.**", FirstName = "FName", LastName = "LName", Roles = new Collection<Role> { new Role { Id = (int)RoleType.Appraiser } } },
ServiceArea = new AppraiserServiceArea { Latitude = 0, Longitude = 0 },
Id = 1
};
var order = new Order
{
Id = 1,
Latitude = 0,
Longitude = 0,
AcceptedAppraiserUser = appraiser,
OrderPublicId = "AAA",
AppraiserOrderDeliveryType = (int)AppraiserOrderDeliveryType.SMS
};
Target.SendOrderInvitations(order, new AppraiserUser[] { appraiser });
_appraiserOrderRepository.Received(1).Add(Arg.Is<AppraiserOrder>(e => e.AppraiserUser.Id == appraiser.Id && e.Order.Id == order.Id));
_backgroundService.Received(1).AddTask(TaskTypeEnum.SendAppraiserOrderInvitationSMS, Arg.Any<Dictionary<TaskParamsKey, string>>());
}
public void CreateUser(AppraiserUser user)
{
if (user == null)
throw new ArgumentNullException("user");
_appraiserUserRepository.Add(user);
}
public void ChangeTrackingRepository_TrackStatusChanges()
{
var appraiserUserRepository = new AppraiserUserRepository(this.DbFactory);
var userDetail = new AppraiserUser()
{
User = new User()
{
LastName = "LastName",
FirstName = "FirtsName",
Email = "*****@*****.**"
},
Status = AppraiserUserStatus.Inactive
};
appraiserUserRepository.Add(userDetail);
DVSContext.SaveChanges();
var dbEntry = appraiserUserRepository.GetById(userDetail.Id);
dbEntry.Status = AppraiserUserStatus.Active;
DVSContext.SaveChanges();
dbEntry.Status = AppraiserUserStatus.Suspended;
DVSContext.SaveChanges();
var changes = _repository.GetAppraiserStatusHistory(userDetail.User.Id).OrderBy(e => e.ChangeEntity.ChangeSet.Date).ToArray();
changes.Should().HaveCount(3);
changes[0].OldValue.Should().BeNull();
changes[0].NewValue.Should().Be(AppraiserUserStatus.Inactive.ToString());
changes[1].OldValue.Should().Be(AppraiserUserStatus.Inactive.ToString());
changes[1].NewValue.Should().Be(AppraiserUserStatus.Active.ToString());
changes[2].OldValue.Should().Be(AppraiserUserStatus.Active.ToString());
changes[2].NewValue.Should().Be(AppraiserUserStatus.Suspended.ToString());
}
public void Update(AppraiserUser userAppraiser)
{
if (userAppraiser == null)
throw new ArgumentNullException("userAppraiser");
_appraiserUserRepository.Update(userAppraiser);
}
private AppraiserUser GetAppraiserUser()
{
if (_appraiserUser == null)
_appraiserUser = _appraiserManagement.GetById(_currentUser.Id);
if (_appraiserUser == null)
throw new ApplicationException(String.Format("User [{0}] is not appraiser", _currentUser.Email));
return _appraiserUser;
}
public void DeleteLicense(AppraiserUser currentUser, string licenseId)
{
if (currentUser == null)
{
throw new ArgumentNullException("appraiser user");
}
var licenseDel = currentUser.Licenses.SingleOrDefault(l => l.Id.ToString() == licenseId);
if (licenseDel != null)
currentUser.Licenses.Remove(licenseDel);
}
public void SaveFeeItem(AppraiserUser currentUser, FeeItemViewModel currentFee)
{
if (currentUser == null)
throw new ArgumentNullException("appraiser user");
if (currentFee == null)
throw new ArgumentNullException("currentFee");
if (string.IsNullOrEmpty(_refManager.GetProductNameById(currentFee.ProductType)))
throw new ArgumentException("fee product id");
var fee = currentUser.Fees.SingleOrDefault(e => e.Id.ToString() == currentFee.Id);
if (fee == null)
{
fee = new AppraiserFee();
currentUser.Fees.Add(fee);
}
fee.Amount = currentFee.Fee.Value;
fee.ProductId = currentFee.ProductType;
}
public void AppraiserUserRepositoryTest_Add_AndNewUser()
{
var userDetail = new AppraiserUser()
{
User = new User()
{
LastName = "LastName",
FirstName = "FirtsName",
Email = "*****@*****.**"
},
Status = AppraiserUserStatus.Active
};
Target.Add(userDetail);
DVSContext.SaveChanges();
userDetail.User.Id.Should().BeGreaterThan(0);
var newUserDetail = Target.GetById(userDetail.Id);
newUserDetail.User.Email.Should().Be("*****@*****.**");
}
public void AppraiserUserRepositoryTest_Delete()
{
//arrage
var userDetail = new AppraiserUser()
{
User = new User()
{
LastName = "LastName",
FirstName = "FirtsName",
Email = "*****@*****.**"
},
Status = AppraiserUserStatus.Active
};
Target.Add(userDetail);
DVSContext.SaveChanges();
//act
Target.Delete(userDetail.Id);
DVSContext.SaveChanges();
//assert
Target.GetById(userDetail.Id).Should().BeNull();
}
public void LicenseManagerTest_SaveNewLicenseForAppraiser()
{
string userEmail = "*****@*****.**";
User testUser = new User() {
FirstName = "John",
LastName = "Doe",
Email = userEmail,
IsPasswordClear = true,
Roles = new Role[] { new Role() { Id = (int)RoleType.Appraiser, DisplayName = "Appraiser" } }
};
AppraiserUser userAppraiser = new AppraiserUser() {
User = testUser,
StatusId = SafeConvert.ToString(AppraiserUserStatus.Active),
Licenses = new List<License>()
};
this.DVSContext.AppraiserUsers.Add(userAppraiser);
this.DVSContext.SaveChanges();
AppraiserUser testAppraiser = this.DVSContext.AppraiserUsers.SingleOrDefault(u => u.User.Email == userEmail);
LicenseItemViewModel currentLicense = new LicenseItemViewModel() {
Id = Guid.NewGuid().ToString(),
Number = "1234",
ExpirationDate = DateTime.Now.AddMonths(2),
State = "KS",
Status = LicenseStatus.Active,
CHUMSId = "111111",
FHARoster = true,
LicenseType = null
};
Target.SaveLicense(testAppraiser, currentLicense);
Action act = () => this.DVSContext.SaveChanges();
act.ShouldNotThrow();
AppraiserUser testAppraiserWithLicenses = this.DVSContext.AppraiserUsers.SingleOrDefault(u => u.User.Email == userEmail);
testAppraiserWithLicenses.Licenses.Should().HaveCount(1);
License license = testAppraiserWithLicenses.Licenses.Single();
license.LicenseType.Should().BeNull();
}
public void SendOrderInvitations(Order order, AppraiserUser[] appraisers)
{
List<AppraiserOrder> appraiserOrders = new List<AppraiserOrder>();
foreach (var appraiser in appraisers)
{
var appraiserOrder = _appraiserOrderRepository.Get(e => e.AppraiserId == appraiser.Id && e.OrderId == order.Id).SingleOrDefault();
if (appraiserOrder == null)
{
appraiserOrder = new AppraiserOrder()
{
AppraiserUser = appraiser,
Distance = (float)GeographyManager.CalculateDistance((double)order.Longitude, (double)order.Latitude, (double)appraiser.ServiceArea.Longitude, (double)appraiser.ServiceArea.Latitude),
Order = order,
IsDeclined = false,
CreatedDate = DateTime.Now
};
_appraiserOrderRepository.Add(appraiserOrder);
appraiserOrders.Add(appraiserOrder);
}
}
_taskManager.SendAppraiserOrderInvitations(appraiserOrders.ToArray(), (AppraiserOrderDeliveryType)order.AppraiserOrderDeliveryType);
}
public void SetInitialScore(AppraiserUser appraiser)
{
if (appraiser.User.PrimaryRole.RoleType != RoleType.Appraiser && appraiser.User.PrimaryRole.RoleType != RoleType.CompanyAdminAndAppraiser)
{
return;
}
if (appraiser.QC != null && appraiser.QC.ScoreHistory != null && appraiser.QC.ScoreHistory.Any())
{
return;
}
appraiser.QC = new AppraiserQC();
AppraiserScoreHistoryEntry firstEntry = new AppraiserScoreHistoryEntry()
{
ChangeReasonId = (int)AppraiserScoreChangeReasonType.InitialSetup,
ScoreValue = 95,
ChangeDate = DateTime.Now
};
appraiser.QC.ScoreHistory = new List<AppraiserScoreHistoryEntry>();
appraiser.QC.ScoreHistory.Add(firstEntry);
appraiser.QC.DocumentAuditStateId = (int)QCDocumentAuditState.Incomplete;
}
public AppraiserUser CheckAndCreateAppraiserUser(User user, string password, AppraiserUserStatus defaultStatus)
{
if (user == null)
throw new ArgumentNullException("user");
if (string.IsNullOrEmpty(password))
throw new ArgumentNullException("password");
string salt = Guid.NewGuid().ToString().Replace("-", "");
user.Salt = salt;
user.PasswordHash = PasswordHelper.EncodePassword(user.Salt, password, MembershipPasswordFormat.Hashed);
if (GetByEmail(user.Email) != null)
throw new ArgumentException("AppraiserUserDetails already exists for user ", user.Email);
AppraiserUser appraiserUser = new AppraiserUser();
appraiserUser.User = user;
appraiserUser.Status = defaultStatus;
SetInitialScore(appraiserUser);
CreateUser(appraiserUser);
return appraiserUser;
}
public void Proceed_action_should_redirect_to_profile_view()
{
const string userEmail = "some email";
var principal = Substitute.For<IPrincipal>();
var identity = Substitute.For<IIdentity>();
identity.Name.Returns(userEmail);
principal.Identity.Returns(identity);
var context = Substitute.For<HttpContextBase>();
context.User.Returns(principal);
var controllerContext = Substitute.For<ControllerContext>();
controllerContext.HttpContext.Returns(context);
var appraisalCompanyAdmin = new AppraiserUser { Company = new AppraisalCompanyDetail { Id = 123 } };
AppraiserManagement.GetByEmail(userEmail).Returns(appraisalCompanyAdmin);
var viewModel = new AppraisalCompanyBankingViewModel();
Target.ControllerContext = controllerContext;
//act
var actionResult = Target.Proceed();
AppraisalCompanyWizardService.Received().SetActiveStatus(appraisalCompanyAdmin.Company.Id, userEmail);
actionResult.Should().NotBeNull().And.BeOfType<RedirectToRouteResult>();
((RedirectToRouteResult)actionResult).RouteValues.Should().HaveCount(3);
((RedirectToRouteResult)actionResult).RouteValues["action"].Should().Be(NameHelper.AppraiserProfile.Index);
((RedirectToRouteResult)actionResult).RouteValues["area"].Should().Be(NameHelper.AppraiserProfile.Area);
((RedirectToRouteResult)actionResult).RouteValues["controller"].Should().Be(NameHelper.AppraiserProfile.Controller);
}
public void banking_post_action_should_redirect_to_itself()
{
//arrange
const string userEmail = "some email";
var principal = Substitute.For<IPrincipal>();
var identity = Substitute.For<IIdentity>();
identity.Name.Returns(userEmail);
principal.Identity.Returns(identity);
var context = Substitute.For<HttpContextBase>();
context.User.Returns(principal);
var controllerContext = Substitute.For<ControllerContext>();
controllerContext.HttpContext.Returns(context);
var appraisalCompanyAdmin = new AppraiserUser { Company = new AppraisalCompanyDetail { Id = 123 } };
AppraiserManagement.GetByEmail(userEmail).Returns(appraisalCompanyAdmin);
var viewModel = new AppraisalCompanyBankingViewModel();
Target.ControllerContext = controllerContext;
AppraisalCompanyWizardService.GetAppraisalCompanyBanking(Arg.Any<int>()).Returns(new AppraisalCompanyBankingViewModel());
//act
var actionResult = Target.Banking(viewModel, null);
//assert
actionResult.Should().NotBeNull().And.BeOfType<RedirectToRouteResult>();
((RedirectToRouteResult)actionResult).RouteValues.Should().HaveCount(1);
((RedirectToRouteResult)actionResult).RouteValues["action"].Should().Be("Banking");
}
public void banking_action_should_populate_account_number_with_old_value()
{
//arrange
var oldModel= new AppraisalCompanyBankingViewModel { AccountNumber = "oldnumber" };
var viewModel = new AppraisalCompanyBankingViewModel { AccountNumber = "newnumber" };
var appraiserUser = new AppraiserUser
{
Company = new AppraisalCompanyDetail
{
Id = 1
}
};
AppraisalCompanyProfileService.GetAppraisalCompanyBanking(Arg.Any<int>()).Returns(oldModel);
var controllerContext = Substitute.For<ControllerContext>();
controllerContext.HttpContext.User.Identity.Name.Returns(String.Empty);
AppraiserManagement.GetByEmail(Arg.Any<string>()).Returns(appraiserUser);
Target.ControllerContext = controllerContext;
//act
Target.Banking(viewModel, null);
//assert
AppraisalCompanyProfileService.Received().SaveAppraisalCompanyBanking(1, Arg.Is<AppraisalCompanyBankingViewModel>(b => b.AccountNumber==oldModel.AccountNumber));
}
private List<AppraiserUser> GetAppraiserUsersWithValidLicense(string licenseState, int usersCount)
{
var appraisers = new List<AppraiserUser>();
for (int i = 1; i <= usersCount; i++)
{
var user = new User
{
FirstName = "First " + i,
LastName = "Name" + i,
IsPasswordClear = true,
Email = String.Format("user{0}@mail.com", i)
};
user.Roles = new List<Role>(new Role[] { _referenceManagement.GetRoleWithoutCache(RoleType.Appraiser) });
var appraiserUser = new AppraiserUser
{
User = user,
StatusId = AppraiserUserStatus.Active.ToString(),
Licenses = new List<License>() { new License { State = "NY", Status = LicenseStatus.Active, LicenseNumber = "test" + i, StatusValue = LicenseStatus.Active.ToString() } }
};
appraisers.Add(appraiserUser);
}
return appraisers;
}
private bool IsValidAppraiserByLicense(AppraiserUser appraiserUser, string stateId, bool isFHA)
{
if (appraiserUser.Status == AppraiserUserStatus.Active)
return appraiserUser.Licenses.Any(e => e.State == stateId && e.Status == LicenseStatus.Active && (isFHA && e.FHARoster || !isFHA));
else
return false;
}
public void GetAppraiserCompanyInfo_should_throw_exception_if_illegal_branch_id_passed()
{
string email = "*****@*****.**";
int branchId = 1;
var branch = new AppraisalCompanyBranch()
{
Id = branchId,
Name = "branch 1"
};
var company = new AppraisalCompanyDetail()
{
Id = 1,
CompanyName = "company",
Branches = new List<AppraisalCompanyBranch>(new AppraisalCompanyBranch[] { branch }),
Contact = new AppraisalCompanyContact() { PhysicalAddress = new Address() { City = "Minsk" } }
};
var user = new User()
{
Email = email,
Roles = new List<Role>(new Role[] { Singletones.ReferenceManager.GetRole(RoleType.AppraisalCompanyAdmin) })
};
var appraiser = new AppraiserUser()
{
Id = 1,
User = user,
Branch = branch,
Company = company,
};
AppraiserManager.GetByEmail(Arg.Any<string>()).Returns(appraiser);
AppraiserManager.GetById(Arg.Any<int>()).Returns(appraiser);
AppraiserAccessManager.IsOtherUserDataAvailable(Arg.Any<int?>()).Returns(true);
// act
Target.Invoking(a => a.GetAppraiserCompanyInfo(email, null, branchId + 1)).ShouldThrow<ArgumentException>();
}
public void LicenseManager_SaveLicense_Should_save_license()
{
//arrange
var date = DateTime.Now;
var license = new LicenseItemViewModel()
{
Id = "1",
Number = "one",
State = "LA",
Status = LicenseStatus.Active,
ExpirationDate = date
};
var user = new AppraiserUser()
{
Licenses=new List<License>()
};
user.Licenses.Count.Should().Be(0);
//act
_target.SaveLicense(user, license);
//assert
user.Licenses.Count.Should().Be(1);
user.Licenses.Where(l => l.LicenseNumber == license.Number && l.State == license.State && l.Status == LicenseStatus.Active && l.ExpirationDate == date).Count().Should().Be(1);
}
public void LicenseManager_DeleteLicense_Should_delete_license()
{
var licenses = new List<License>();
var date = DateTime.Now;
licenses.Add(new License() { Id = 1, LicenseNumber = "one", State = "NY", Status = LicenseStatus.Active, ExpirationDate = date });
licenses.Add(new License() { Id = 2, LicenseNumber = "two", State = "GU", Status = LicenseStatus.Active, ExpirationDate = date });
licenses.Add(new License() { Id = 3, LicenseNumber = "three", State = "LA", Status = LicenseStatus.Active, ExpirationDate = date });
var user = new AppraiserUser()
{
Licenses = licenses
};
user.Licenses.Count().Should().Be(3);
//act
//assert
_target.DeleteLicense(user, "1");
user.Licenses.Count().Should().Be(2);
user.Licenses.Where(l => l.Id == 1).Count().Should().Be(0);
_target.DeleteLicense(user, "2");
user.Licenses.Count().Should().Be(1);
user.Licenses.Where(l => l.Id == 2).Count().Should().Be(0);
_target.DeleteLicense(user, "3");
user.Licenses.Count().Should().Be(0);
user.Licenses.Where(l => l.Id == 3).Count().Should().Be(0);
}
public AppraiserOrder CreateAppraiserOrder(Order order, AppraiserUser appraiser)
{
throw new NotImplementedException();
}
public void HasAppraiserValidLicense_should_return_true_if_appraiser_have_active_license_valid_for_15_days_minimum()
{
string email = "*****@*****.**";
int userId = 1;
var user = new User()
{
Id = userId,
Email = email,
Roles = new List<Role>(new Role[] { Singletones.ReferenceManager.GetRole(RoleType.Appraiser) })
};
var appraiser = new AppraiserUser()
{
Id = userId,
User = user,
Licenses = new List<License>(new License[]{
new License() {Status = LicenseStatus.Inactive, ExpirationDate = DateTime.Now.AddYears(1) },
new License() {Status = LicenseStatus.Active, ExpirationDate = DateTime.Now.Date.AddDays(16) }
})
};
AppraiserManager.GetByEmail(Arg.Any<string>()).Returns(appraiser);
AppraiserAccessManager.IsOtherUserDataAvailable(Arg.Any<Nullable<int>>()).Returns(true);
// act
Target.HasAppraiserValidLicense(email).Should().BeTrue();
}
public void GetAppraiserCompanyInfo_should_throw_exception_if_user_is_not_assigned_to_company()
{
string email = "*****@*****.**";
int userId = 1;
var user = new User()
{
Id = userId,
Email = email,
Roles = new List<Role>(new Role[] { Singletones.ReferenceManager.GetRole(RoleType.Appraiser) })
};
var appraiser = new AppraiserUser()
{
Id = userId,
User = user
};
UsersManager.GetById(Arg.Any<int>()).Returns(user);
UsersManager.GetByEmail(Arg.Any<string>()).Returns(user);
AppraiserManager.GetById(Arg.Any<int>()).Returns(appraiser);
// act
Target.Invoking(a => a.GetAppraiserCompanyInfo(email, userId, null)).ShouldThrow<SecurityException>();
}
public AppraiserOrder CreateAppraiserOrder(Order order, AppraiserUser appraiser)
{
var appraiserOrder = new AppraiserOrder()
{
AppraiserUser = appraiser,
AppraiserId = appraiser.Id,
Distance = (float)GeographyManager.CalculateDistance((double)order.Longitude, (double)order.Latitude, (double)appraiser.ServiceArea.Longitude, (double)appraiser.ServiceArea.Latitude),
Order = order,
IsDeclined = false,
CreatedDate = DateTime.Now
};
return appraiserOrder;
}
public void SendOrderInvitations(Order order, AppraiserUser[] appraisers)
{
throw new NotImplementedException();
}
public CurrentAppraiserContext(AppraiserUser appraiserUser)
{
if (appraiserUser == null) throw new ArgumentNullException();
AppraiserId = appraiserUser.Id;
}