public void Update(ICacheService cacheService, Account selectedAccount, WorkPeriod currentWorkPeriod)
{
var accountType = cacheService.GetAccountTypeById(selectedAccount.AccountTypeId);
var transactions = Dao.Query(GetCurrentRange(accountType.DefaultFilterType, x => x.AccountId == selectedAccount.Id, currentWorkPeriod)).OrderBy(x => x.Date);
Transactions = transactions.Select(x => new AccountDetailData(x, selectedAccount)).ToList();
if (accountType.DefaultFilterType > 0)
{
var pastDebit = Dao.Sum(x => x.Debit, GetPastRange(accountType.DefaultFilterType, x => x.AccountId == selectedAccount.Id, currentWorkPeriod));
var pastCredit = Dao.Sum(x => x.Credit, GetPastRange(accountType.DefaultFilterType, x => x.AccountId == selectedAccount.Id, currentWorkPeriod));
var pastExchange = Dao.Sum(x => x.Exchange, GetPastRange(accountType.DefaultFilterType, x => x.AccountId == selectedAccount.Id, currentWorkPeriod));
if (pastCredit > 0 || pastDebit > 0)
{
Summaries.Add(new AccountSummaryData(Resources.Total, Transactions.Sum(x => x.Debit), Transactions.Sum(x => x.Credit)));
var detailValue =
new AccountDetailData(
new AccountTransactionValue
{
Name = Resources.PastTransactions,
Credit = pastCredit,
Debit = pastDebit,
Exchange = pastExchange
}, selectedAccount) { IsBold = true };
Transactions.Insert(0, detailValue);
}
}
Summaries.Add(new AccountSummaryData(Resources.GrandTotal, Transactions.Sum(x => x.Debit), Transactions.Sum(x => x.Credit)));
for (var i = 0; i < Transactions.Count; i++)
{
Transactions[i].Balance = (Transactions[i].Debit - Transactions[i].Credit);
if (i > 0) (Transactions[i].Balance) += (Transactions[i - 1].Balance);
}
}
public void Update(Account selectedAccount, DateTime? start, DateTime? end)
{
Start = start;
End = end;
var transactions = Dao.Query(GetCurrentRange(start, end, x => x.AccountId == selectedAccount.Id)).OrderBy(x => x.Date);
Transactions = transactions.Select(x => new AccountDetailData(x, selectedAccount)).ToList();
if (start.HasValue)
{
var pastDebit = Dao.Sum(x => x.Debit, GetPastRange(start, x => x.AccountId == selectedAccount.Id));
var pastCredit = Dao.Sum(x => x.Credit, GetPastRange(start, x => x.AccountId == selectedAccount.Id));
var pastExchange = Dao.Sum(x => x.Exchange, GetPastRange(start, x => x.AccountId == selectedAccount.Id));
if (pastCredit > 0 || pastDebit > 0)
{
Summaries.Add(new AccountSummaryData(Resources.TransactionTotal, Transactions.Sum(x => x.Debit), Transactions.Sum(x => x.Credit)));
var detailValue =
new AccountDetailData(
new AccountTransactionValue
{
Date = start.GetValueOrDefault(),
Name = Resources.BalanceBroughtForward,
Credit = pastCredit,
Debit = pastDebit,
Exchange = pastExchange
}, selectedAccount) { IsBold = true };
Transactions.Insert(0, detailValue);
}
}
if (end.HasValue && end != start)
{
var futureDebit = Dao.Sum(x => x.Debit, GetFutureRange(end, x => x.AccountId == selectedAccount.Id));
var futureCredit = Dao.Sum(x => x.Credit, GetFutureRange(end, x => x.AccountId == selectedAccount.Id));
var futureExchange = Dao.Sum(x => x.Exchange, GetFutureRange(end, x => x.AccountId == selectedAccount.Id));
if (futureCredit > 0 || futureDebit > 0)
{
Summaries.Add(new AccountSummaryData(Resources.DateRangeTotal, Transactions.Sum(x => x.Debit), Transactions.Sum(x => x.Credit)));
var detailValue =
new AccountDetailData(
new AccountTransactionValue
{
Date = end.GetValueOrDefault(),
Name = Resources.BalanceAfterDate,
Credit = futureCredit,
Debit = futureDebit,
Exchange = futureExchange
}, selectedAccount) { IsBold = true };
Transactions.Add(detailValue);
}
}
Summaries.Add(new AccountSummaryData(Resources.GrandTotal, Transactions.Sum(x => x.Debit), Transactions.Sum(x => x.Credit)));
for (var i = 0; i < Transactions.Count; i++)
{
Transactions[i].Balance = (Transactions[i].Debit - Transactions[i].Credit);
if (i > 0) (Transactions[i].Balance) += (Transactions[i - 1].Balance);
}
}
public AccountRowViewModel(Account account, AccountTransactionDocumentType documentType, IAccountService accountService, ICacheService cacheService)
{
_account = account;
Amount = accountService.GetDefaultAmount(documentType, account);
Description = accountService.GetDescription(documentType, account);
TargetAccounts = GetAccountSelectors(documentType, account, accountService, cacheService).ToList();
}
public bool CanMakeAccountTransaction(Account selectedAccount)
{
if (DefaultSourceAccountId == selectedAccount.Id || DefaultTargetAccountId == selectedAccount.Id) return true;
if (SourceAccountTypeId == selectedAccount.AccountTypeId && DefaultSourceAccountId == 0) return true;
if (TargetAccountTypeId == selectedAccount.AccountTypeId && DefaultTargetAccountId == 0) return true;
return false;
}
public void PrintAccountTransactions(Account account, WorkPeriod workPeriod, Printer printer, string filter)
{
var range = _accountService.GetDateRange(filter, workPeriod);
var summary = _accountService.GetAccountTransactionSummary(account, workPeriod, range.Start, range.End);
var totalBalance = summary.Transactions.Sum(x => x.Debit - x.Credit).ToString(LocalSettings.ReportCurrencyFormat);
var report = new SimpleReport("");
report.AddParagraph("Header");
report.AddParagraphLine("Header", _settingService.ProgramSettings.UserInfo);
report.AddParagraphLine("Header", Resources.AccountTransaction, true);
report.AddParagraphLine("Header", "");
report.AddParagraphLine("Header", string.Format("{0}: {1}", string.Format(Resources.Name_f, Resources.Account), account.Name));
report.AddParagraphLine("Header", string.Format("{0}: {1}", Resources.Balance, totalBalance));
report.AddParagraphLine("Header", "");
report.AddColumnLength("Transactions", "15*", "35*", "15*", "15*", "20*");
report.AddColumTextAlignment("Transactions", TextAlignment.Left, TextAlignment.Left, TextAlignment.Right, TextAlignment.Right, TextAlignment.Right);
report.AddTable("Transactions", Resources.Date, Resources.Description, Resources.Debit, Resources.Credit, Resources.Balance);
foreach (var ad in summary.Transactions)
{
report.AddRow("Transactions", ad.Date.ToShortDateString(), ad.Name, ad.DebitStr, ad.CreditStr, ad.BalanceStr);
}
foreach (var sum in summary.Summaries)
{
report.AddBoldRow("Transactions", "", sum.Caption, sum.Debit, sum.Credit, sum.Balance);
}
_printerService.PrintReport(report.Document, printer);
}
public AccountTransactionDocument CreateDocument(Account account, string description, decimal amount, decimal exchangeRate, IList<AccountData> accounts, IList<ForeignCurrency> currencies)
{
var result = new AccountTransactionDocument { Name = Name, DocumentTypeId = Id };
foreach (var accountTransactionType in TransactionTypes)
{
var transaction = AccountTransaction.Create(accountTransactionType);
var amountRate = GetExchangeRate(accountTransactionType.ForeignCurrencyId, currencies);
amount = amount * amountRate;
transaction.UpdateAmount(amount, exchangeRate, accounts);
transaction.UpdateAccount(MasterAccountTypeId, account.Id);
if (accounts != null && accounts.Count > 0)
{
if (transaction.SourceAccountTypeId != MasterAccountTypeId &&
transaction.SourceTransactionValue.AccountId == 0)
{
var ac = accounts.FirstOrDefault(x => x.AccountTypeId == transaction.SourceAccountTypeId);
if (ac != null) transaction.SetSourceAccount(ac.AccountTypeId, ac.AccountId);
}
if (transaction.TargetAccountTypeId != MasterAccountTypeId &&
transaction.TargetTransactionValue.AccountId == 0)
{
var ac = accounts.FirstOrDefault(x => x.AccountTypeId == transaction.TargetAccountTypeId);
if (ac != null) transaction.SetTargetAccount(ac.AccountTypeId, ac.AccountId);
}
}
if (!string.IsNullOrEmpty(description))
{
transaction.UpdateDescription(description);
}
result.AccountTransactions.Add(transaction);
}
return result;
}
private IEnumerable<AccountSelectViewModel> GetAccountSelectors(AccountTransactionDocumentType documentType, Account selectedAccount, IAccountService accountService, ICacheService cacheService)
{
var accountMap = documentType.AccountTransactionDocumentAccountMaps.FirstOrDefault(x => x.AccountId == selectedAccount.Id);
return accountMap != null
? documentType.GetNeededAccountTypes().Select(x => new AccountSelectViewModel(accountService, cacheService.GetAccountTypeById(x), accountMap.MappedAccountId, accountMap.MappedAccountName))
: documentType.GetNeededAccountTypes().Select(x => new AccountSelectViewModel(accountService, cacheService.GetAccountTypeById(x)));
}
public AccountTransaction AddNewTransaction(AccountTransactionType template, int accountTypeId, int accountId, Account account, decimal amount, decimal exchangeRate)
{
var transaction = AccountTransaction.Create(template, accountTypeId, accountId);
transaction.UpdateAccounts(account.AccountTypeId, account.Id);
transaction.UpdateAmount(amount, exchangeRate);
AccountTransactions.Add(transaction);
return transaction;
}
public void AddAccountTransaction(Ticket ticket, Account sourceAccount, Account targetAccount, decimal amount, decimal exchangeRate)
{
var transactionType = _cacheService.FindAccountTransactionType(sourceAccount.AccountTypeId, targetAccount.AccountTypeId, sourceAccount.Id, targetAccount.Id);
if (transactionType != null)
{
ticket.TransactionDocument.AddNewTransaction(transactionType, ticket.GetTicketAccounts(), amount, exchangeRate);
}
}
public void CreateAccountTransaction(Account sourceAccount, Account targetAccount, decimal amount, decimal exchangeRate)
{
var transactionType = _cacheService.FindAccountTransactionType(sourceAccount.AccountTypeId, targetAccount.AccountTypeId,
sourceAccount.Id, targetAccount.Id);
if (transactionType != null)
{
_accountDao.CreateAccountTransaction(transactionType, sourceAccount, targetAccount, amount, exchangeRate);
}
}
public void AddAccountTransaction(Ticket ticket, Account sourceAccount, Account targetAccount, decimal amount, decimal exchangeRate)
{
var transactionType = _cacheService.FindAccountTransactionType(sourceAccount.AccountTypeId, targetAccount.AccountTypeId, sourceAccount.Id, targetAccount.Id);
if (transactionType != null)
{
var transaction = ticket.TransactionDocument.AddNewTransaction(transactionType, ticket.GetTicketAccounts(), amount, exchangeRate);
transaction.UpdateDescription(string.Format("{0} - {1}: {2}", transaction.Name, Resources.TicketNumber, ticket.TicketNumber));
}
}
private void OnDocumentCreation(EventParameters<DocumentCreationData> obj)
{
SelectedAccount = obj.Value.Account;
DocumentTemplate = obj.Value.DocumentTemplate;
Description = _accountService.GetDescription(obj.Value.DocumentTemplate, obj.Value.Account);
Amount = _accountService.GetDefaultAmount(obj.Value.DocumentTemplate, obj.Value.Account);
RaisePropertyChanged(() => Description);
RaisePropertyChanged(() => Amount);
RaisePropertyChanged(() => AccountName);
}
public AccountTransactionDocument CreateDocument(Account account, string description, decimal amount)
{
Debug.Assert(account.AccountTemplateId == MasterAccountTemplateId);
var result = new AccountTransactionDocument { Name = Name };
foreach (var accountTransactionTemplate in TransactionTemplates)
{
var transaction = AccountTransaction.Create(accountTransactionTemplate);
transaction.Name = description;
transaction.Amount = amount;
if (transaction.SourceTransactionValue.AccountTemplateId == MasterAccountTemplateId)
transaction.SetSoruceAccount(account.AccountTemplateId, account.Id);
if (transaction.TargetTransactionValue.AccountTemplateId == MasterAccountTemplateId)
transaction.SetTargetAccount(account.AccountTemplateId, account.Id);
result.AccountTransactions.Add(transaction);
}
return result;
}
public void AddAccountTransaction(Ticket ticket, Account sourceAccount, Account targetAccount, decimal amount, decimal exchangeRate)
{
var transactionType = _cacheService.FindAccountTransactionType(sourceAccount.AccountTypeId, targetAccount.AccountTypeId, sourceAccount.Id, targetAccount.Id);
if (transactionType != null)
{
var transaction = ticket.TransactionDocument.AddNewTransaction(transactionType, ticket.GetTicketAccounts(), amount, exchangeRate);
transaction.UpdateDescription(string.Format("{0} - {1}: {2}", transaction.Name, Resources.TicketNumber, ticket.TicketNumber));
_applicationState.NotifyEvent(RuleEventNames.AccountTransactionAddedToTicket,
new
{
Ticket = ticket,
TransactionTypeName = transactionType.Name,
SourceAccountName = sourceAccount.Name,
TargetAccountName = targetAccount.Name,
Amount = amount,
ExchangeRate = exchangeRate
});
}
}
public AccountTransactionSummary GetAccountTransactionSummary(Account selectedAccount, WorkPeriod currentWorkPeriod, DateTime? start = null, DateTime? end = null)
{
if (!start.HasValue)
{
var accountType = _cacheService.GetAccountTypeById(selectedAccount.AccountTypeId);
if (accountType != null)
{
if (accountType.DefaultFilterType == 1) start = DateTime.Now.MonthStart();
if (accountType.DefaultFilterType == 2) start = DateTime.Now.StartOfWeek();
if (accountType.DefaultFilterType == 3) start = currentWorkPeriod.StartDate;
}
}
return
AccountTransactionSummaryBuilder.Create()
.ForAccount(selectedAccount)
.WithStartDate(start)
.WithEndDate(end)
.Build();
}
public void CreateBatchAccountTransactionDocument(string documentName)
{
if (!string.IsNullOrEmpty(documentName))
{
var document = _cacheService.GetAccountTransactionDocumentTypeByName(documentName);
if (document != null)
{
var accounts = GetDocumentAccounts(document);
foreach (var account in accounts)
{
var map = document.AccountTransactionDocumentAccountMaps.FirstOrDefault(
y => y.AccountId == account.Id);
if (map != null && map.MappedAccountId > 0)
{
var targetAccount = new Account { Id = map.MappedAccountId, Name = map.MappedAccountName };
var amount = GetDefaultAmount(document, account);
if (amount != 0)
CreateTransactionDocument(account, document, "", amount,
new List<Account> { targetAccount });
}
}
}
}
}
public void CreateTransactionDocument(Account selectedAccount, AccountTransactionDocumentType documentType, string description, decimal amount, IEnumerable<Account> accounts)
{
var exchangeRate = GetExchangeRate(selectedAccount, documentType.ExchangeTemplate);
_accountDao.CreateTransactionDocument(selectedAccount, documentType, description, amount, exchangeRate, accounts);
}
public decimal GetExchangeRate(Account account, string template)
{
if (account.ForeignCurrencyId == 0) return 1;
if (!string.IsNullOrWhiteSpace(template))
{
decimal d;
decimal.TryParse(template, out d);
return d;
}
return _cacheService.GetCurrencyById(account.ForeignCurrencyId).ExchangeRate;
}
public string GetDescription(AccountTransactionDocumentType documentType, Account account)
{
var result = documentType.DescriptionTemplate;
if (string.IsNullOrEmpty(result)) return result;
while (Regex.IsMatch(result, "\\[:([^\\]]+)\\]"))
{
var match = Regex.Match(result, "\\[:([^\\]]+)\\]");
result = result.Replace(match.Groups[0].Value, GetCustomData(account, match.Groups[1].Value));
}
if (result.Contains("[MONTH]")) result = result.Replace("[MONTH]", DateTime.Now.ToMonthName());
if (result.Contains("[NEXT MONTH]")) result = result.Replace("[NEXT MONTH]", DateTime.Now.ToNextMonthName());
if (result.Contains("[WEEK]")) result = result.Replace("[WEEK]", DateTime.Now.WeekOfYear().ToString(CultureInfo.CurrentCulture));
if (result.Contains("[NEXT WEEK]")) result = result.Replace("[NEXT WEEK]", (DateTime.Now.NextWeekOfYear()).ToString(CultureInfo.CurrentCulture));
if (result.Contains("[YEAR]")) result = result.Replace("[YEAR]", (DateTime.Now.Year).ToString(CultureInfo.CurrentCulture));
if (result.Contains("[ACCOUNT NAME]")) result = result.Replace("[ACCOUNT NAME]", account.Name);
return result;
}
public decimal GetDefaultAmount(AccountTransactionDocumentType documentType, Account account)
{
decimal result = 0;
if (!string.IsNullOrEmpty(documentType.DefaultAmount))
{
var da = documentType.DefaultAmount;
if (Regex.IsMatch(da, "\\[:([^\\]]+)\\]"))
{
var match = Regex.Match(da, "\\[:([^\\]]+)\\]");
da = GetCustomData(account, match.Groups[1].Value);
decimal.TryParse(da, out result);
}
else if (da == string.Format("[{0}]", Resources.Balance))
{
result = Math.Abs(GetAccountBalance(account.Id));
}
else if (da == string.Format("[{0}]", "BalanceEx"))
{
var er = GetExchangeRate(account, documentType.ExchangeTemplate);
result = er != 1
? Math.Abs(GetAccountExchangeBalance(account.Id) * er)
: Math.Abs(GetAccountBalance(account.Id));
}
else decimal.TryParse(da, out result);
}
return result;
}
public static Ticket Create(Department department, Account account, decimal exchangeRate, IEnumerable<CalculationType> calculationTypes)
{
var ticket = new Ticket
{
DepartmentId = department.Id,
AccountTypeId = department.TicketTemplate.SaleTransactionType.TargetAccountTypeId,
TransactionDocument = new AccountTransactionDocument()
};
ticket.UpdateAccount(account, exchangeRate);
foreach (var calculationType in calculationTypes.OrderBy(x => x.Order))
{
ticket.AddCalculation(calculationType, calculationType.Amount);
}
return ticket;
}
public void AddPayment(PaymentType paymentType, Account account, decimal amount, decimal exchangeRate, int userId)
{
var transaction = TransactionDocument.AddNewTransaction(paymentType.AccountTransactionType, GetTicketAccounts(account), amount, exchangeRate);
transaction.UpdateDescription(transaction.Name + " [" + account.Name + "]");
var payment = new Payment { AccountTransaction = transaction, Amount = amount, Name = account.Name, PaymentTypeId = paymentType.Id, UserId = userId };
Payments.Add(payment);
LastPaymentDate = DateTime.Now;
RemainingAmount = GetRemainingAmount();
}
public void AddPayment(PaymentType paymentType, Account account, decimal amount, decimal exchangeRate, int userId)
{
var transaction = TransactionDocument.AddNewTransaction(paymentType.AccountTransactionType, AccountTypeId, AccountId, account, amount, exchangeRate);
var payment = new Payment { AccountTransaction = transaction, Amount = amount, Name = account.Name, PaymentTypeId = paymentType.Id };
Payments.Add(payment);
LastPaymentDate = DateTime.Now;
RemainingAmount = GetRemainingAmount();
if (RemainingAmount == 0)
{
PaidItems.Clear();
}
}
public void Setup()
{
Pizza = CreateMenuItem(1, "Pizza", 10);
Cola = CreateMenuItem(2, "Cola", 5);
Beer = CreateMenuItem(3, "Beer", 10);
var saleAccountType = new AccountType { Name = "Sales Accounts", Id = 1 };
var taxAccountType = new AccountType { Name = "Tax Accounts", Id = 2 };
var receivableAccountType = new AccountType { Name = "Receivable Accounts", Id = 3 };
var discountAccountType = new AccountType { Name = "Discount Accounts", Id = 4 };
var defaultSaleAccount = new Account { AccountTypeId = saleAccountType.Id, Name = "Sales", Id = 1 };
ReceivableAccount = new Account { AccountTypeId = receivableAccountType.Id, Name = "Receivables", Id = 2 };
var stateTaxAccount = new Account { AccountTypeId = taxAccountType.Id, Name = "State Tax", Id = 3 };
var localTaxAccount = new Account { AccountTypeId = taxAccountType.Id, Name = "Local Tax", Id = 4 };
var defaultDiscountAccount = new Account { AccountTypeId = discountAccountType.Id, Name = "Discount", Id = 5 };
var saleTransactionType = new AccountTransactionType
{
Id = 1,
Name = "Sale Transaction",
SourceAccountTypeId = saleAccountType.Id,
TargetAccountTypeId = receivableAccountType.Id,
DefaultSourceAccountId = defaultSaleAccount.Id,
DefaultTargetAccountId = ReceivableAccount.Id
};
var localTaxTransactionType = new AccountTransactionType
{
Id = 2,
Name = "Local Tax Transaction",
SourceAccountTypeId = taxAccountType.Id,
TargetAccountTypeId = receivableAccountType.Id,
DefaultSourceAccountId = localTaxAccount.Id,
DefaultTargetAccountId = ReceivableAccount.Id
};
var stateTaxTransactionType = new AccountTransactionType
{
Id = 3,
Name = "State Tax Transaction",
SourceAccountTypeId = taxAccountType.Id,
TargetAccountTypeId = receivableAccountType.Id,
DefaultSourceAccountId = stateTaxAccount.Id,
DefaultTargetAccountId = ReceivableAccount.Id
};
DiscountTransactionType = new AccountTransactionType
{
Id = 4,
Name = "Discount Transaction",
SourceAccountTypeId = receivableAccountType.Id,
TargetAccountTypeId = discountAccountType.Id,
DefaultSourceAccountId = ReceivableAccount.Id,
DefaultTargetAccountId = defaultDiscountAccount.Id
};
var stateTax = new TaxTemplate { Name = "State Tax", Rate = 25, Id = 1 };
stateTax.TaxTemplateMaps.Add(new TaxTemplateMap());
stateTax.AccountTransactionType = stateTaxTransactionType;
var localTax = new TaxTemplate { Name = "Local Tax", Rate = 3, Id = 2 };
localTax.TaxTemplateMaps.Add(new TaxTemplateMap { MenuItemId = Cola.Id });
localTax.TaxTemplateMaps.Add(new TaxTemplateMap { MenuItemId = Beer.Id });
localTax.AccountTransactionType = localTaxTransactionType;
TaxTemplates = new List<TaxTemplate> { stateTax, localTax };
TicketType = new TicketType { SaleTransactionType = saleTransactionType, TaxIncluded = true };
}
public DocumentCreationData(Account account,AccountTransactionDocumentTemplate documentTemplate)
{
Account = account;
DocumentTemplate = documentTemplate;
}
public void PrintAccountTransactions(Account account)
{
_reportService.PrintAccountTransactions(account, _applicationState.CurrentWorkPeriod, _applicationState.GetReportPrinter());
}
public void AddChangePayment(ChangePaymentType changePaymentType, Account account, decimal amount, decimal exchangeRate, int userId)
{
var transaction = TransactionDocument.AddNewTransaction(changePaymentType.AccountTransactionType, AccountTypeId, AccountId, account, amount, exchangeRate);
var payment = new ChangePayment { AccountTransaction = transaction, Amount = amount, Name = account.Name, ChangePaymentTypeId = changePaymentType.Id };
ChangePayments.Add(payment);
}
public string GetCustomData(Account account, string fieldName)
{
var cd = _accountDao.GetEntityCustomDataByAccountId(account.Id);
return string.IsNullOrEmpty(cd) ? "" : Entity.GetCustomData(cd, fieldName);
}
public void UpdateAccount(Account account, decimal exchangeRate)
{
if (account == null) return;
foreach (var transaction in TransactionDocument.AccountTransactions)
{
transaction.UpdateAccounts(AccountTypeId, account.Id);
}
AccountId = account.Id;
AccountTypeId = account.AccountTypeId;
AccountName = account.Name;
ExchangeRate = exchangeRate;
}
public void AddChangePayment(ChangePaymentType changePaymentType, Account account, decimal amount, decimal exchangeRate, int userId)
{
var transaction = TransactionDocument.AddNewTransaction(changePaymentType.AccountTransactionType, GetTicketAccounts(account), amount, exchangeRate);
transaction.UpdateDescription(transaction.Name + " [" + account.Name + "]");
var payment = new ChangePayment { AccountTransaction = transaction, Amount = amount, Name = account.Name, ChangePaymentTypeId = changePaymentType.Id, UserId = userId };
ChangePayments.Add(payment);
}
