public async Task DeleteAccountCommand_UserReturnTrue_ExecuteDeletion()
{
// Arrange
crudserServiceMock.Setup(x => x.DeleteAndSaveAsync <Account>(It.IsAny <int>()))
.Returns(Task.CompletedTask);
var balanceCalculationService = new Mock <IBalanceCalculationService>();
var dialogServiceSetup = new Mock <IDialogService>();
dialogServiceSetup.Setup(x => x.ShowConfirmMessage(It.IsAny <string>(), It.IsAny <string>(), null, null))
.Returns(Task.FromResult(true));
var viewModel = new AccountListViewModel(crudserServiceMock.Object,
balanceCalculationService.Object,
dialogServiceSetup.Object,
new Mock <ISettingsFacade>().Object,
new Mock <INavigationService>().Object);
// Act
await viewModel.DeleteAccountCommand.ExecuteAsync(new AccountViewModel());
// Assert
crudserServiceMock.Verify(x => x.DeleteAndSaveAsync <Account>(It.IsAny <int>()), Times.Once);
}
//TODO Update this to MVVM pattern
public void OnDelete(object sender, EventArgs e)
{
var mi = ((MenuItem)sender);
AccountListViewModel.DeleteAccountAsync(mi.CommandParameter.ToString());
DisplayAlert("Delete", "Account number " + mi.CommandParameter + " deleted", "OK");
}
public async Task DeleteAccountCommand_UserReturnTrue_ExecuteDeletion()
{
// Arrange
mediatorMock.Setup(x => x.Send(It.IsAny <DeleteAccountByIdCommand>(), default))
.ReturnsAsync(Unit.Value);
var balanceCalculationService = new Mock <IBalanceCalculationService>();
var dialogServiceSetup = new Mock <IDialogService>();
dialogServiceSetup.Setup(x => x.ShowConfirmMessageAsync(It.IsAny <string>(), It.IsAny <string>(), null, null))
.Returns(Task.FromResult(true));
var viewModel = new AccountListViewModel(mediatorMock.Object,
new Mock <IMapper>().Object,
balanceCalculationService.Object,
dialogServiceSetup.Object,
new Mock <ISettingsFacade>().Object,
new Mock <INavigationService>().Object);
// Act
await viewModel.DeleteAccountCommand.ExecuteAsync(new AccountViewModel());
// Assert
mediatorMock.Verify(x => x.Send(It.IsAny <DeleteAccountByIdCommand>(), default), Times.Once);
}
public void DeleteAccountCommand_AccountNull_DoNothing()
{
// Arrange
var deleteCalled = false;
accountServiceMock.Setup(x => x.DeleteAccount(It.IsAny <Account>())).Callback(() => deleteCalled = true);
var balanceCalculationManager = new Mock <IBalanceCalculationManager>();
var dialogServiceSetup = new Mock <IDialogService>();
dialogServiceSetup.Setup(x => x.ShowConfirmMessage(It.IsAny <string>(), It.IsAny <string>(), null, null))
.Returns(Task.FromResult(true));
var viewModel = new AccountListViewModel(accountServiceMock.Object,
balanceCalculationManager.Object,
new Mock <ISettingsManager>().Object,
dialogServiceSetup.Object,
new Mock <IMvxNavigationService>().Object);
// Act
viewModel.DeleteAccountCommand.Execute(null);
// Assert
deleteCalled.ShouldBeFalse();
}
public void DeleteAccountCommand_UserReturnFalse_SkipDeletion()
{
// Arrange
crudserServiceMock.Setup(x => x.DeleteAndSaveAsync <Account>(It.IsAny <int>()))
.Returns(Task.CompletedTask);
var balanceCalculationService = new Mock <IBalanceCalculationService>();
var dialogServiceSetup = new Mock <IDialogService>();
dialogServiceSetup.Setup(x => x.ShowConfirmMessage(It.IsAny <string>(), It.IsAny <string>(), null, null))
.Returns(Task.FromResult(false));
var viewModel = new AccountListViewModel(crudserServiceMock.Object,
balanceCalculationService.Object,
dialogServiceSetup.Object,
new Mock <ISettingsFacade>().Object,
new Mock <IMvxLogProvider>().Object,
new Mock <IMvxNavigationService>().Object);
// Act
viewModel.DeleteAccountCommand.Execute(new AccountViewModel());
// Assert
crudserServiceMock.Verify(x => x.DeleteAndSaveAsync <Account>(It.IsAny <int>()), Times.Never);
}
public void DeleteAccountCommand_UserReturnFalse_SkipDeletion()
{
var deleteCalled = false;
accountRepository.Setup(x => x.Delete(It.IsAny <Account>())).Callback(() => deleteCalled = true);
var paymentRepoSetup = new Mock <IPaymentRepository>();
paymentRepoSetup.SetupAllProperties();
var dialogServiceSetup = new Mock <IDialogService>();
dialogServiceSetup.Setup(x => x.ShowConfirmMessage(It.IsAny <string>(), It.IsAny <string>(), null, null))
.Returns(Task.FromResult(false));
var viewModel = new AccountListViewModel(accountRepository.Object,
paymentRepoSetup.Object,
dialogServiceSetup.Object
);
viewModel.DeleteAccountCommand.Execute(new Account {
Id = 3
});
deleteCalled.ShouldBeFalse();
}
public void DeleteAccountCommand_UserReturnTrue_ExecuteDeletion()
{
// Arrange
var deleteCalled = false;
accountServiceMock.Setup(x => x.DeleteAccount(It.IsAny <Account>()))
.Callback(() => deleteCalled = true)
.Returns(Task.CompletedTask);
var balanceCalculationManager = new Mock <IBalanceCalculationManager>();
var dialogServiceSetup = new Mock <IDialogService>();
dialogServiceSetup.Setup(x => x.ShowConfirmMessage(It.IsAny <string>(), It.IsAny <string>(), null, null))
.Returns(Task.FromResult(true));
var viewModel = new AccountListViewModel(accountServiceMock.Object,
balanceCalculationManager.Object,
new Mock <ISettingsManager>().Object,
new Mock <IModifyDialogService>().Object,
dialogServiceSetup.Object);
// Act
viewModel.DeleteAccountCommand.Execute(new AccountViewModel(new Account {
Data = { Id = 3 }
}));
// Assert
deleteCalled.ShouldBeTrue();
}
public IActionResult Index()
{
List <User> users;
List <AccountListViewModel> aList = new List <AccountListViewModel>();
try
{
users = _context.Users
.OrderBy(p => p.UserId)
.ToList();
foreach (User u in users)
{
AccountListViewModel acc = u.CopyTo <AccountListViewModel>();
aList.Add(acc);
}
return(View(aList));
}
catch (Exception ex)
{
return(View("Error", new ErrorViewModel {
Exception = ex
}));
}
}
public async Task <IActionResult> AccountList(AccountListViewModel model)
{
var query = _dbContext.User.AsQueryable();
var predicate = PredicateBuilder.True <DashboardUser>();
if (model.SearchUserName.NotNullOrEmpty())
{
predicate = predicate.And(x => x.Name.Contains(model.SearchUserName));
}
var countFuture = query.Where(predicate).DeferredCount().FutureValue();
var itemsFuture = query.Where(predicate).Skip((model.PageNum - 1) * model.PageSize)
.Take(model.PageSize).Future();
var total = await countFuture.ValueAsync();
var items = await itemsFuture.ToListAsync();
return(Ok(new
{
total = total,
rows = items.Select(x => new
{
Id = x.Id,
Name = x.Name
})
}.Success()));
}
public ActionResult SearchAccountListByType(int GenreID, int ClassesID)
{
AccountListViewModel accountListViewModel = new AccountListViewModel();
AccountBusinessLayer actBal = new AccountBusinessLayer();
string s = System.Web.HttpContext.Current.Session["UserID"].ToString();
List <Account> accounts = new List <Account>();
if (ClassesID != 0)
{
accounts = actBal.SearchList(int.Parse(s), GenreID, ClassesID);
}
else
{
accounts = actBal.SearchList(int.Parse(s), GenreID);
}
accountListViewModel.Accounts = AccountSealed(accounts);
accountListViewModel.Today = DateTime.Today.ToString("yyyy-MM-dd");
List <Genre> types = actBal.GetTypeList();//从数据库中获取数据
ViewBag.ListTypes = types;
return(View("AccountList", accountListViewModel));
}
public void IsAllAccountsEmpty_TwoAccountExcluded_False()
{
// Arrange
var balanceCalculationManager = new Mock <IBalanceCalculationManager>();
accountServiceMock.Setup(x => x.GetNotExcludedAccounts()).ReturnsAsync(new List <Account>());
accountServiceMock.Setup(x => x.GetExcludedAccounts())
.ReturnsAsync(new List <Account>
{
new Account(),
new Account()
});
var viewModel = new AccountListViewModel(accountServiceMock.Object,
balanceCalculationManager.Object,
new Mock <ISettingsManager>().Object,
new Mock <IDialogService>().Object,
new Mock <IMvxNavigationService>().Object);
// Act
viewModel.ViewAppearing();
// Assert
viewModel.HasNoAccounts.ShouldBeFalse();
}
public AccountListPage()
{
InitializeComponent();
//Bind to ViewModel for entire Content Page. Binding is inherited by all children on the page
BindingContext = new AccountListViewModel();
}
public void ExcludedAccounts_AccountsAvailable_MatchesRepository()
{
// Arrange
var balanceCalculationManager = new Mock <IBalanceCalculationManager>();
accountServiceMock.Setup(x => x.GetNotExcludedAccounts()).ReturnsAsync(new List <Account>());
accountServiceMock.Setup(x => x.GetExcludedAccounts())
.ReturnsAsync(new List <Account>
{
new Account {
Data = { Id = 22 }
},
new Account {
Data = { Id = 33 }
}
});
var viewModel = new AccountListViewModel(accountServiceMock.Object,
balanceCalculationManager.Object,
new Mock <ISettingsManager>().Object,
new Mock <IModifyDialogService>().Object,
new Mock <IDialogService>().Object,
new Mock <IMvxNavigationService>().Object);
// Act
viewModel.LoadedCommand.Execute();
// Assert
viewModel.ExcludedAccounts.Count.ShouldEqual(2);
viewModel.ExcludedAccounts[0].Id.ShouldEqual(22);
viewModel.ExcludedAccounts[1].Id.ShouldEqual(33);
}
/// <summary>
/// Get a list of managers and site engineer in the system
/// GET: ~/Accountant/Accountant/AccountListView
/// </summary>
/// <returns></returns>
public ActionResult AccountListView()
{
var siteEngineerList = Accountant.getAllSiteEngineer();
var siteEnigeerVMList = new List <SiteEngineerViewModel>();
foreach (var siteEngineer in siteEngineerList)
{
siteEnigeerVMList.Add(new SiteEngineerViewModel()
{
Id = siteEngineer.Id.ToString(),
Name = siteEngineer.Name
});
}
var managerList = Accountant.getAllManger();
var managerVMList = new List <ManagerViewModel>();
foreach (var manager in managerList)
{
managerVMList.Add(new ManagerViewModel()
{
Id = manager.Id.ToString(),
Name = manager.Name
});
}
var model = new AccountListViewModel()
{
SiteEngineers = siteEnigeerVMList,
Managers = managerVMList
};
return(View(model));
}
public Test(int userId)
{
InitializeComponent();
this.CurrentUser = _repository.FindBy(u => u.UserID == userId).SingleOrDefault();
Loadaccounts();
var viewModel = new AccountListViewModel(this.CurrentUser.AccountUsers.ToList());
accountuserbindingSource.DataSource = viewModel.Account;
}
public void DeleteAccountCommand_CascadeDeletePayments()
{
var deleteCalled = false;
accountRepository.Setup(x => x.Delete(It.IsAny <Account>())).Callback(() => deleteCalled = true);
var accountRepo = accountRepository.Object;
accountRepo.Data = new ObservableCollection <Account>();
var accountData = new Account()
{
CurrentBalance = 0,
Id = 300,
Name = "Test Account"
};
accountRepo.Data.Add(accountData);
var mockPaymentRepo = new Mock <IPaymentRepository>();
mockPaymentRepo.SetupAllProperties();
mockPaymentRepo.Setup(c => c.Delete(It.IsAny <Payment>())).Callback((Payment payment) =>
{
mockPaymentRepo.Object.Data.Remove(payment);
});
var paymentRepo = mockPaymentRepo.Object;
paymentRepo.Data = new ObservableCollection <Payment>();
paymentRepo.Data.Add(new Payment()
{
Id = 1,
Amount = 100,
ChargedAccountId = accountData.Id
});
paymentRepo.Data.Add(new Payment()
{
Id = 2,
Amount = 200,
ChargedAccountId = accountData.Id
});
var dialogServiceSetup = new Mock <IDialogService>();
dialogServiceSetup.Setup(x => x.ShowConfirmMessage(It.IsAny <string>(), It.IsAny <string>(), null, null))
.Returns(Task.FromResult(true));
var viewModel = new AccountListViewModel(accountRepo,
paymentRepo,
dialogServiceSetup.Object
);
viewModel.DeleteAccountCommand.Execute(accountData);
deleteCalled.ShouldBeTrue();
Assert.AreEqual(null, paymentRepo.Data.FirstOrDefault(p => p.Id == 1));
}
public void IsAllAccountsEmpty_AccountsEmpty_True()
{
var endofMonthManagerSetup = new Mock <IEndOfMonthManager>();
accountRepository.Setup(x => x.GetList(null)).Returns(new List <Account>());
var vm = new AccountListViewModel(accountRepository.Object, new Mock <IPaymentRepository>().Object, null, endofMonthManagerSetup.Object);
vm.LoadedCommand.Execute();
vm.IsAllAccountsEmpty.ShouldBeTrue();
}
/// <summary>
/// Konstruktor der eine AccountListViewModel als DataContext setzt und eine E-Mail
/// mit annimmt um die Daten dieser im Fenster zu setzen.
/// </summary>
/// <param name="dataContext"></param>
/// <param name="email"></param>
public SendEmailWindow(AccountListViewModel dataContext, EmailViewModel email)
{
InitializeComponent();
DataContext = dataContext;
receiverTextBox.Text = email.Sender;
subjectTextBox.Text = email.Subject;
messageTextBox.Text = email.Message;
messageTextBox.Focus();
Show();
}
public void AllAccounts_NoAccountsAvailable_MatchesRepository()
{
var endofMonthManagerSetup = new Mock <IEndOfMonthManager>();
accountRepository.Setup(x => x.GetList(null)).Returns(new List <Account>());
accountRepository.Setup(x => x.GetList(It.IsAny <Expression <Func <Account, bool> > >())).Returns(new List <Account>());
var vm = new AccountListViewModel(accountRepository.Object, new Mock <IPaymentRepository>().Object, null, endofMonthManagerSetup.Object);
vm.LoadedCommand.Execute();
vm.AllAccounts.Any().ShouldBeFalse();
}
private void LoadData()
{
settingsViewModel = AccountListViewModel.Instance;
DataContext = settingsViewModel;
if (((AccountListViewModel)DataContext).SelectedAccountIndex != -1)
{
senderComboBox.SelectedIndex = ((AccountListViewModel)DataContext).SelectedAccountIndex;
}
}
public async Task <IActionResult> ListAccounts()
{
var result = await((BeBelfiusConnector)Storage.Connector).GetAccountsAsync();
AccountListViewModel model = new AccountListViewModel();
if (result.GetStatus() == ResultStatus.DONE)
{
model.Accounts = result.GetData();
}
return(View(model));
}
public async Task <AccountListViewModel> GetModelForAccountList(string search, int?indexPage, string sortOrder)
{
int itemsPerPage = _gridConfiguration.ItemsPerPage;
ICollection <AppUser> users = await _accountRepository.ListAsync();
if (search != null)
{
users = users.Where(u => u.FullName.ToLower().Contains(search.ToLower()) || u.Email.ToLower().Contains(search.ToLower())).ToList();
}
switch (sortOrder)
{
case "fullname_desc":
users = users.OrderByDescending(u => u.FullName).ToList();
break;
case "email":
users = users.OrderBy(u => u.Email).ToList();
break;
case "email_desc":
users = users.OrderByDescending(u => u.Email).ToList();
break;
case "status":
users = users.OrderBy(u => u.AccountStatus.ToString()).ToList();
break;
case "status_desc":
users = users.OrderByDescending(u => u.AccountStatus.ToString()).ToList();
break;
default:
users = users.OrderBy(u => u.FullName).ToList();
break;
}
AccountListViewModel vm = new AccountListViewModel
{
Users = users
.Skip(((indexPage ?? 1) - 1) * itemsPerPage)
.Take(itemsPerPage),
SearchStr = search,
PageIndex = indexPage ?? 1,
TotalItems = users.Count(),
CurrentSort = sortOrder,
FullNameSort = String.IsNullOrEmpty(sortOrder) ? "fullname_desc" : "",
EmailSort = sortOrder == "email" ? "email_desc" : "email",
StatusSort = sortOrder == "status" ? "status_desc" : "status",
ItemsPerPage = itemsPerPage
};
return(vm);
}
public IActionResult Edit(AccountListViewModel model)
{
var user = HttpContext.User.Identity.Name;
if (!ModelState.IsValid)
{
return(View());
}
_accountService.UpdateAccountEdit(user, model);
return(RedirectToAction("Index"));
}
public void IsAllAccountsEmpty_OneAccount_False()
{
var settingsManagerMock = new Mock <ISettingsManager>();
accountRepository.Setup(x => x.GetList(null)).Returns(new List <AccountViewModel> {
new AccountViewModel()
});
var endofMonthManagerSetup = new Mock <IEndOfMonthManager>();
var vm = new AccountListViewModel(accountRepository.Object, new Mock <IPaymentManager>().Object, null, endofMonthManagerSetup.Object, settingsManagerMock.Object);
vm.LoadedCommand.Execute();
vm.IsAllAccountsEmpty.ShouldBeFalse();
}
public void DeleteAccountCommand_CascadeDeletePayments()
{
var deleteCalled = false;
var accountData = new Account {
CurrentBalance = 0,
Id = 300,
Name = "Test Account"
};
var testList = new ObservableCollection <Payment>
{
new Payment
{
Id = 1,
Amount = 100,
ChargedAccountId = accountData.Id
},
new Payment
{
Id = 2,
Amount = 200,
ChargedAccountId = accountData.Id
}
};
accountRepository.Setup(x => x.Delete(It.IsAny <Account>())).Callback(() => deleteCalled = true);
accountRepository.Setup(x => x.GetList(null)).Returns(new List <Account> {
accountData
});
var mockPaymentRepo = new Mock <IPaymentRepository>();
mockPaymentRepo.Setup(c => c.Delete(It.IsAny <Payment>()))
.Callback((Payment payment) => { testList.Remove(payment); });
mockPaymentRepo.Setup(x => x.GetList(It.IsAny <Expression <Func <Payment, bool> > >())).Returns(testList);
var endofMonthManagerSetup = new Mock <IEndOfMonthManager>();
var dialogServiceSetup = new Mock <IDialogService>();
dialogServiceSetup.Setup(x => x.ShowConfirmMessage(It.IsAny <string>(), It.IsAny <string>(), null, null))
.Returns(Task.FromResult(true));
var settingsManagerMock = new Mock <ISettingsManager>();
var viewModel = new AccountListViewModel(accountRepository.Object, mockPaymentRepo.Object,
dialogServiceSetup.Object, endofMonthManagerSetup.Object, settingsManagerMock.Object);
viewModel.DeleteAccountCommand.Execute(accountData);
deleteCalled.ShouldBeTrue();
testList.Any().ShouldBeFalse();
}
public async Task <ActionResult> Index()
{
var users = await UserManager.Users.OrderBy(x => x.UserName).ToArrayAsync();
var model = new AccountListViewModel(users);
model.Accounts.AddRowAction(ShowUserAction);
model.Accounts.AddRowAction(EditUserAction);
model.Accounts.AddRowAction(ChangePasswordAction);
model.Accounts.AddRowAction(GrantRolesAction);
model.Accounts.AddRowAction(LockUserAction);
model.Accounts.AddRowAction(DeleteUserAction);
model.Accounts.Actions.Add(AddUserAction());
return(View(model));
}
public void IncludedAccounts_NoAccountsAvailable_MatchesRepository()
{
var settingsManagerMock = new Mock <ISettingsManager>();
var endofMonthManagerSetup = new Mock <IEndOfMonthManager>();
accountRepository.Setup(x => x.GetList(null)).Returns(new List <AccountViewModel>());
accountRepository.Setup(x => x.GetList(It.IsAny <Expression <Func <AccountViewModel, bool> > >()))
.Returns(new List <AccountViewModel>());
var vm = new AccountListViewModel(accountRepository.Object, new Mock <IPaymentManager>().Object, null,
endofMonthManagerSetup.Object, settingsManagerMock.Object, new Mock <IModifyDialogService>().Object);
vm.LoadedCommand.Execute();
vm.IncludedAccounts.Any().ShouldBeFalse();
vm.ExcludedAccounts.Any().ShouldBeFalse();
}
public void IsAllAccountsEmpty_OneAccount_False()
{
var settingsManagerMock = new Mock <ISettingsManager>();
accountRepository.SetupSequence(x => x.GetList(It.IsAny <Expression <Func <AccountViewModel, bool> > >()))
.Returns(new List <AccountViewModel>
{
new AccountViewModel()
});
var endofMonthManagerSetup = new Mock <IEndOfMonthManager>();
var vm = new AccountListViewModel(accountRepository.Object, new Mock <IPaymentManager>().Object, null,
endofMonthManagerSetup.Object, settingsManagerMock.Object, new Mock <IModifyDialogService>().Object);
vm.LoadedCommand.Execute();
vm.IsAllAccountsEmpty.ShouldBeFalse();
}
public ActionResult SearchAccountListByMonth(DateTime date1, DateTime date2)
{
AccountListViewModel accountListViewModel = new AccountListViewModel();
AccountBusinessLayer actBal = new AccountBusinessLayer();
string s = System.Web.HttpContext.Current.Session["UserID"].ToString();
List <Account> accounts = actBal.SearchList(int.Parse(s), date1, date2);
accountListViewModel.Accounts = AccountSealed(accounts);
accountListViewModel.Today = DateTime.Today.ToString("yyyy-MM-dd");
List <Genre> types = actBal.GetTypeList();//从数据库中获取数据
ViewBag.ListTypes = types;
return(View("AccountList", accountListViewModel));
}
public AccountListViewModel GetAccounts(IDataProtector protector, List <FilterValue> filterValues, int pageSize, int pageIndex)
{
Mapper.Initialize(cfg => cfg.CreateMap <Account, AccountRegisterViewModel>()
.ForMember(dest => dest.Id, opt => opt.MapFrom(src => protector.Protect(src.Id.ToString())))
);
var resultList = Mapper.Map <List <Account>, List <AccountRegisterViewModel> >(_accountDao.GetAll(filterValues, pageSize, pageIndex));
var itemResult = new AccountListViewModel()
{
Accounts = resultList
};
var count = _accountDao.GetCount(filterValues);
return(ConfigurePagination(itemResult, pageIndex, pageSize, filterValues, count));
}
public void PropertiesTest()
{
var vm = new AccountListViewModel();
TestsHelper.TestPublicPropertiesGetSet(vm, x=>vm.Model);
}
