Esempio n. 1
0
		private void InitCurrentUser(User user, AppraiserUser appraiserUser)
		{
			appraiserUser.User = user;

			SecurityContext.CurrentUser.Returns(user);
			CurrentAppraiser.CurrentAppraiser.Returns(appraiserUser);
		}
Esempio n. 2
0
		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);
		}
Esempio n. 3
0
		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>>());
		}
Esempio n. 5
0
		public void CreateUser(AppraiserUser user)
		{
			if (user == null)
				throw new ArgumentNullException("user");

			_appraiserUserRepository.Add(user);
		}
Esempio n. 6
0
		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());
		}
Esempio n. 7
0
		public void Update(AppraiserUser userAppraiser)
		{
			if (userAppraiser == null)
				throw new ArgumentNullException("userAppraiser");

			_appraiserUserRepository.Update(userAppraiser);
		}
Esempio n. 8
0
		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;
		}
Esempio n. 9
0
		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);
		}
Esempio n. 10
0
		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;
		}
Esempio n. 11
0
		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("*****@*****.**");
		}
Esempio n. 12
0
		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();
		}
Esempio n. 13
0
		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();
		}
Esempio n. 14
0
		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);
		}
Esempio n. 15
0
		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;
		}
Esempio n. 16
0
		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;
		}
Esempio n. 21
0
		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;
		}
Esempio n. 22
0
		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>();
		}
Esempio n. 23
0
		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);		
		}
Esempio n. 24
0
		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);
		}
Esempio n. 25
0
		public AppraiserOrder CreateAppraiserOrder(Order order, AppraiserUser appraiser)
		{
			throw new NotImplementedException();
		}
Esempio n. 26
0
		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();
		}
Esempio n. 27
0
		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>();
		}
Esempio n. 28
0
		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;
		}
Esempio n. 29
0
		public void SendOrderInvitations(Order order, AppraiserUser[] appraisers)
		{
			throw new NotImplementedException();
		}
Esempio n. 30
0
		public CurrentAppraiserContext(AppraiserUser appraiserUser)
		{
			if (appraiserUser == null) throw new ArgumentNullException();

			AppraiserId = appraiserUser.Id;
		}