private Task <List <Client> > GetAttorneyClients(Payee payee, Organization organization)
{
return(clients.All()
.Where(c => c.Residencies.Any(r => r.IsActive && r.OrganizationId == organization.Id))
.Where(c => c.Residencies.Any(r => r.Attorneys.Any(a => a.Id == payee.Id)))
.AsNoTracking()
.ToListAsync());
}
private IEnumerable <Account> GetAccounts(SubsidiaryBatchReceiptEditorForm editor)
{
var ids = editor.Transactions
.Select(t => t.AccountId)
.ToArray();
return(accounts.All()
.Where(a => ids.Contains(a.Id))
.ToArray());
}
public void EnsureNameIsUnique(AddOrEditOrganizationCommand message)
{
Logger.Trace("EnsureNameIsUnique::{0}", message.Editor.Name);
var isUnique = !organizations.All()
.Where(o => o.Id != message.Editor.OrganizationId)
.Any(o => o.Name.Equals(message.Editor.Name));
if (isUnique)
{
return;
}
message.ModelState.AddModelError("Name", "The organization name ({0}) is in use by another organization."
.FormatWith(message.Editor.Name));
}
private async Task <BatchExpenseEditorForm> GetForBatch(int batchId)
{
var expenseTypes = GetExpenseTypes();
var batch = await batches.GetById(batchId)
.Where(b => !b.Committed)
.Include(b => b.Fund)
.Include(b => b.Payee)
.Include(b => b.TransactionSubType)
.AsNoTracking()
.FirstOrDefaultAsync();
if (batch == null)
{
return(null);
}
var transactions = await expenses.All()
.Include(e => e.ExpenseCategory)
.Include(e => e.Account)
.Where(e => e.TransactionBatchId == batch.Id)
.AsNoTracking()
.ToArrayAsync();
if (batch.Fund is SubsidiaryFund)
{
return(SubsidiaryBatchExpenseEditorForm.FromBatch(batch, transactions, expenseTypes));
}
if (batch.Fund is ClientFund)
{
return(ClientBatchExpenseEditorForm.FromBatch(batch, transactions, expenseTypes));
}
return(null);
}
public async Task <AccountEditorForm> Handle(AccountEditorFormQuery message)
{
Logger.Trace("Handle");
if (message.AccountId.HasValue)
{
var account = await accounts.GetById(message.AccountId.Value)
.AsNoTracking()
.FirstOrDefaultAsync();
var fund = await funds.All().OfType <SubsidiaryFund>()
.AsNoTracking()
.FirstOrDefaultAsync(f => f.Subsidiaries.Any(s => s.Id == message.AccountId.Value));
return(AccountEditorForm.FromFund(fund, account));
}
if (message.ParentFundId.HasValue)
{
var fund = await funds.GetById(message.ParentFundId.Value)
.OfType <SubsidiaryFund>()
.AsNoTracking()
.FirstOrDefaultAsync();
return(AccountEditorForm.FromFund(fund));
}
return(null);
}
public async Task Can_select_tenant_organization()
{
var command = new SelectTenantOrganizationCommand("foo", "some/url");
organizations.All()
.Returns(new[] { new Organization {
Abbreviation = "foo"
} }.AsAsyncQueryable());
var result = await handler.Handle(command);
Assert.IsInstanceOfType(result, typeof(SuccessResult));
tenantKeyManager.Received()
.SetTenantKey(command.TenantKey);
tenantUrlHelper.Received()
.TransformTenantUrl(command.ReturnUrl, command.TenantKey);
}
public Task Handle(ClientActivationToggledNotification notification)
{
Logger.Trace("Handle");
accounts.All().OfType <ClientAccount>()
.Where(a => a.Residency.ClientId == notification.Client.Id)
.ForEach(a =>
{
a.IsActive = !a.IsActive;
});
return(unitOfWork.SaveChangesAsync());
}
public async Task Handle(ClientDetailsQuery command, ClientDetails response)
{
Logger.Trace("Handle");
if (response == null)
{
return;
}
response.Accounts = await accounts.All()
.Where(a => a.Residency.Client.Id == response.Client.Id)
.AsNoTracking()
.ToArrayAsync();
}
private void EnsureExpenseCategoryIsDistinct(AddOrEditExpenseCategoryCommand request)
{
Logger.Trace("EnsureExpenseCategoryIsDistinct");
var duplicateCategories = categories.All()
.Where(c => c.Id != request.Editor.ExpenseCategoryId)
.Any(c => c.Name == request.Editor.Name);
if (!duplicateCategories)
{
return;
}
request.ModelState.AddModelError("Name", "Duplicate Expense Category not allowed");
}
public void CheckNumberAreUnique(AddOrEditCheckCommand request)
{
Logger.Trace("CheckNumberAreUnique");
var existingCheck = checks.All()
.Where(c => c.CheckNumber.ToString() == request.Editor.CheckNumber)
.Where(c => c.FundId == request.Editor.FundId);
if (existingCheck.IsNullOrEmpty())
{
return;
}
request.ModelState.AddModelError("CheckNumber", "Check number ({0}) is already used".FormatWith(existingCheck.First().CheckNumber));
}
public async Task <ICommandResult> Handle(SelectTenantOrganizationCommand message)
{
Logger.Trace("Handle");
var organization = await organizations.All()
.FirstOrDefaultAsync(o => o.Abbreviation.Equals(message.TenantKey, StringComparison.InvariantCultureIgnoreCase));
if (organization != null)
{
tenantKeyManager.SetTenantKey(organization.Abbreviation);
return(new SuccessResult(tenantUrlHelper.TransformTenantUrl(message.ReturnUrl, organization.Abbreviation)));
}
return(new FailureResult("Organization Abbreviation '{0}' does not exist.".FormatWith(message.TenantKey)));
}
private void EnsureReceiptSourceIsDistinct(AddOrEditReceiptSourceCommand request)
{
Logger.Trace("EnsureReceiptSourceIsDistinct");
var duplicateSources = sources.All()
.Where(c => c.Id != request.Editor.ReceiptSourceId)
.Any(c => c.Name == request.Editor.Name);
if (!duplicateSources)
{
return;
}
request.ModelState.AddModelError("Name", "Duplicate Receipt Source not allowed");
}
public async Task Handle(QueryDashboard command, DashboardResult response)
{
Logger.Trace("Handle");
if (response == null)
{
return;
}
var items = await funds.All()
.ToArrayAsync();
response.Widgets.Add(new FundsWidget {
Funds = items
});
}
public async Task <TrasferAmountEditorForm> Handle(TrasferAmountEditorFormQuery query)
{
Logger.Trace("Handle::Fund::{0}::Client::{1}", query.FundId, query.ClientId);
var payee = await payees.All()
.Where(p => p.Name == "System")
.Where(p => !p.IsUserSelectable)
.FirstOrDefaultAsync();
return(new TrasferAmountEditorForm
{
FundId = query.FundId,
ClientId = query.ClientId,
PayeeId = payee.Id
});
}
private void EnsureSubsidiaryAccountNameIsUnique(AddOrEditAccountCommand message)
{
Logger.Trace("EnsureSubsidiaryAccountNameIsUnique::{0}", message.Editor.Name);
var isUniqueOrAllowed = !accounts.All()
.Where(a => a is SubsidiaryAccount)
.Where(a => a.Id != message.Editor.AccountId)
.Any(a => a.Name.Equals(message.Editor.Name));
if (isUniqueOrAllowed)
{
return;
}
message.ModelState.AddModelError("Name", "The account name ({0}) is already in use."
.FormatWith(message.Editor.Name));
}
public async Task Handle(ClientDetailsQuery command, ClientDetails response)
{
Logger.Trace("Handle");
if (response == null)
{
return;
}
response.Orders = await orders.All()
.Where(o => !o.IsSatified)
.Where(o => o.Residency.Client.Id == response.Client.Id)
.OrderByDescending(o => o.IsPropertyDamage)
.ThenBy(o => o.Created)
.AsNoTracking()
.ToArrayAsync();
}
public async Task Can_get_payee_details()
{
var organizationId = 24;
var organization = new Organization {Id = organizationId};
tenantOrganizationProvider.GetTenantOrganization().Returns(organization);
var payeeId = 42;
var payee = new Payee {Id = payeeId, Organization = organization, OrganizationId = organizationId};
var query = new PayeeDetailsQuery(payeeId: payeeId);
payees.GetById(Arg.Is(payeeId))
.Returns(new[] {payee}.AsAsyncQueryable());
clients.All()
.Returns(Enumerable.Empty<Client>().AsAsyncQueryable());
var result = await handler.Handle(query);
Assert.IsInstanceOfType(result, typeof(PayeeDetails));
Assert.AreEqual(result.Payee.Id, payee.Id);
}
public async Task Handle(ClientAddedOrUpdatedNotification notification)
{
Logger.Trace("Handle");
if (!featureService.IsEnabled(Feature.Funds))
{
return;
}
var fund = await funds.All().OfType <ClientFund>()
.FirstOrDefaultAsync();
var existingAccounts = await accounts.All().OfType <ClientAccount>()
.Where(a => a.Residency.Client.Id == notification.Client.Id)
.ToArrayAsync();
var accountTypes = accountTypeLookup.All
.Where(a => a.IsDefault)
.ToArray();
accountTypes.Where(t => existingAccounts.All(a => a.AccountType.Id != t.Id))
.ForEach(accountType =>
{
var account = accountType.BuildClientAccount(notification.Client, fund.Organization);
if (account.Name.Equals("Savings", StringComparison.InvariantCultureIgnoreCase))
{
account.BankNumber = notification.Request.Editor.BankAccount;
}
account.Fund = fund;
fund.ClientAccounts.Add(account);
Logger.Info("Created {0} for client {1}, {2}",
account.Name, notification.Client.LastName, notification.Client.FirstName);
});
await unitOfWork.SaveChangesAsync();
}
public async Task Handle(QueryDashboard command, DashboardResult response)
{
Logger.Trace("Handle");
if (response == null)
{
return;
}
var search = new SearchPager {
IsActive = true, PageSize = 5, Page = 1
};
var widget = new BatchesWidget
{
Batches = await batches.GetBySearch(search)
.Take(search.PageSize)
.ToArrayAsync(),
Funds = await funds.All()
.ToArrayAsync()
};
response.Widgets.Add(widget);
}
public void Duplicate_name_fails()
{
var name = "foo";
var command = GetCommand(add: true);
command.Editor.Name = name;
organizations.All()
.Returns(new[] { new Organization {
Name = name
} }.AsAsyncQueryable());
handler.EnsureNameIsUnique(command);
Assert.IsFalse(command.ModelState.IsValid);
Assert.IsTrue(command.ModelState.ContainsKey("Name"));
}
public IQueryable <ReceiptBatch> All()
{
return(batches.All()
.OfType <ReceiptBatch>());
}
public IQueryable <Expense> All()
{
return(transactions.All()
.OfType <Expense>());
}
public IQueryable <Receipt> All()
{
return(transactions.All()
.OfType <Receipt>());
}
public IQueryable <SubsidiaryAccount> All()
{
return(accounts.All().OfType <SubsidiaryAccount>());
}
public IQueryable <ClientAccount> All()
{
return(accounts.All()
.OfType <ClientAccount>());
}
public IQueryable <ExpenseBatch> All()
{
return(batches.All()
.OfType <ExpenseBatch>());
}
public IQueryable <TransferBatch> All()
{
return(batches.All()
.OfType <TransferBatch>());
}
