public ExpenseFlowSettings CreateExpenseFlowSettings(int flowId, bool canFlow, FlowRule rule,
bool isRegularExpenses, decimal amount)
{
var commands = _unitOfWork.GetCommandRepository <ExpenseFlowSettings>();
var entity = new ExpenseFlowSettings
{
ExpenseFlowId = flowId,
CanFlow = canFlow,
Rule = rule,
IsRegularExpenses = isRegularExpenses,
Amount = amount
};
commands.Create(entity);
return(entity);
}
private async Task CreateOrUpdateFlowSettings(DistributionItem item)
{
var settings = await _repository.GetQuery <ExpenseFlowSettings>()
.Where(x => x.ExpenseFlowId == item.Flow.Id)
.SingleOrDefaultAsync();
if (settings == null)
{
settings = new ExpenseFlowSettings
{
ExpenseFlowId = item.Flow.Id,
IsRegularExpenses = item.Mode == DistributionMode.RegularExpenses,
Amount = item.Amount,
CanFlow = true
};
_repository.Create(settings);
}
else
{
settings.IsRegularExpenses = item.Mode == DistributionMode.RegularExpenses;
settings.CanFlow = true;
settings.Amount = item.Amount;
}
}
public async Task Save(IEntityRepository repository, DateTime dateTime)
{
var accountSettingsQueries = repository.GetQuery <AccountFlowSettings>();
var accountIds = Accounts.Select(x => x.Id).ToList();
var accountSettings = await accountSettingsQueries
.Where(x => accountIds.Contains(x.AccountId))
.ToListAsync()
.ConfigureAwait(false);
Accounts.ForEach(x =>
{
var settings = accountSettings.FirstOrDefault(s => s.AccountId == x.Id);
if (settings == null)
{
settings = new AccountFlowSettings
{
AccountId = x.Id,
CanFlow = x.CanFlow
};
repository.Create(settings);
}
else
{
settings.CanFlow = x.CanFlow;
repository.Update(settings);
}
});
var flowSettingsQueries = repository.GetQuery <ExpenseFlowSettings>();
var flowIds = ExpenseFlows.Select(x => x.Id).ToList();
var flowSettings = await flowSettingsQueries
.Where(x => flowIds.Contains(x.ExpenseFlowId))
.ToListAsync()
.ConfigureAwait(false);
ExpenseFlows.ForEach(x =>
{
var settings = flowSettings.FirstOrDefault(s => s.ExpenseFlowId == x.Id);
if (settings == null)
{
settings = new ExpenseFlowSettings
{
ExpenseFlowId = x.Id,
CanFlow = x.CanFlow,
Rule = x.Rule,
Amount = x.Amount
};
repository.Create(settings);
}
else
{
settings.CanFlow = x.CanFlow;
settings.Rule = x.Rule;
settings.Amount = x.Amount;
repository.Update(settings);
}
});
var distribution = new DataAccess.Model.Distribution.Distribution()
{
DateTime = dateTime,
SumFlow = DistributionFlows.Sum(x => x.Amount)
};
repository.Create(distribution);
var accountQueries = repository.GetQuery <Account>();
var flowQueries = repository.GetQuery <ExpenseFlow>();
var accounts = await accountQueries
.Where(x => accountIds.Contains(x.Id))
.ToListAsync()
.ConfigureAwait(false);
var expenseFlows = await flowQueries
.Where(x => flowIds.Contains(x.Id))
.ToListAsync()
.ConfigureAwait(false);
DistributionFlows.ForEach(x =>
{
var flow = new Flow
{
Distribution = distribution,
SourceId = x.SourceId,
RecipientId = x.RecipientId,
Amount = x.Amount
};
repository.Create(flow);
var account = accounts.First(a => a.Id == x.SourceId);
var expenseFlow = expenseFlows.First(f => f.Id == x.RecipientId);
account.AvailBalance -= x.Amount;
repository.Update(account);
expenseFlow.Balance += x.Amount;
repository.Update(expenseFlow);
});
await repository.SaveChangesAsync().ConfigureAwait(false);
}
