public void AddOrUpdate(BudgetTransaction transaction)
{
try
{
BudgetTransaction tranindb;
var transRepo = new TransactionRepository(_db);
var tranindbs = transRepo.Get()
.Where(
t =>
t.PaymentID == transaction.PaymentID &&
t.BudgetID == transaction.BudgetID
).ToList();
tranindb = tranindbs.FirstOrDefault();
if (tranindb == null)
{
// if not found, then add new transaction
Add(transaction);
}
else
{
// if exiting in db, then update
tranindb.Amount = transaction.Amount;
Update(tranindb);
}
}
catch (Exception ex)
{
throw ex;
}
}
public void Update(BudgetTransaction transaction)
{
var tranRepo = new TransactionRepository(_db);
transaction.PrepareToUpdate();
tranRepo.Update(transaction);
tranRepo.Save();
}
public void Add(BudgetTransaction transaction)
{
var tranRepo = new TransactionRepository(_db);
transaction.PrepareToCrate();
tranRepo.Add(transaction);
tranRepo.Save();
}
private bool isLastTransaction(BudgetTransaction transaction)
{
// disable last transaction
return(false);
//using (var transRepo = new TransactionRepository())
//{
// return !(transRepo.Get().Any(t => t.BudgetID == transaction.BudgetID && t.CreatedAt > transaction.CreatedAt));
//}
}
public IBudgetTransactionItemViewModel Create(
ObservableCollection <IAccountLinkViewModel> accountLinks,
BudgetTransaction budgetTransaction,
BudgetTransactionType type)
{
return(new BudgetTransactionItemViewModel(
m_loggerFactory,
accountLinks,
budgetTransaction,
type));
}
public BudgetTransaction ToBudgetTransaction()
{
var budgetTransaction = new BudgetTransaction
{
BudgetTransactionId = BudgetTransactionId,
CreditAccount = SelectedCreditAccount.ToAccountLink(),
DebitAccount = SelectedDebitAccount.ToAccountLink(),
Amount = m_amount
};
return(budgetTransaction);
}
private void CreateExecute(object obj)
{
IBudgetTransactionItemViewModel initialTransactionViewModel =
Transactions
.Single(t => t.Type == BudgetTransactionType.Initial);
IAccountLinkViewModel suggestedCreditAccount =
initialTransactionViewModel.SelectedDebitAccount;
// For the debit account, we want the next unused asset account.
// Failing that, we want an asset account.
// Failing that, we'll take anything!
IEnumerable <IAccountLinkViewModel> assetAccountLinks = m_accountLinks
.Where(alvm => alvm.Type == AccountType.Asset &&
alvm != suggestedCreditAccount);
IEnumerable <IAccountLinkViewModel> usedAssetAccountLinks =
Transactions
.Select(t => t.SelectedDebitAccount)
.Where(al => al.Type == AccountType.Asset);
IEnumerable <IAccountLinkViewModel> unusedAssetAccountLinks =
assetAccountLinks
.Except(usedAssetAccountLinks);
IAccountLinkViewModel suggestedDebitAccount = null;
if (unusedAssetAccountLinks.Any())
{
suggestedDebitAccount = unusedAssetAccountLinks.First();
}
else if (usedAssetAccountLinks.Any())
{
suggestedDebitAccount = usedAssetAccountLinks.First();
}
else if (m_accountLinks.Any())
{
suggestedDebitAccount = m_accountLinks.First();
}
var newTransaction = new BudgetTransaction
{
CreditAccount = suggestedCreditAccount.ToAccountLink(),
DebitAccount = suggestedDebitAccount.ToAccountLink(),
Amount = 0m
};
Transactions.Insert(
Transactions.Count - 1,// we maintain that the surplus transaction is last, so - 1
CreateItemViewModel(newTransaction, BudgetTransactionType.Regular)
);
}
public BudgetTransactionItemViewModel(
ILoggerFactory loggerFactory,
ObservableCollection <IAccountLinkViewModel> accountLinks,
BudgetTransaction budgetTransaction,
BudgetTransactionType type)
{
m_logger = loggerFactory.CreateLogger <BudgetTransactionItemViewModel>();
AccountLinks = accountLinks;
m_amount = budgetTransaction.Amount;
BudgetTransactionId = budgetTransaction.BudgetTransactionId;
SelectedCreditAccount = AccountLinks.Single(al => al.AccountId == budgetTransaction.CreditAccount.AccountId);
SelectedDebitAccount = AccountLinks.Single(al => al.AccountId == budgetTransaction.DebitAccount.AccountId);
Type = type;
}
private IBudgetTransactionItemViewModel CreateItemViewModel(
BudgetTransaction budgetTransaction,
BudgetTransactionType type)
{
IBudgetTransactionItemViewModel transactionViewModel =
m_budgetTransactionItemViewModelFactory.Create(
m_accountLinks,
budgetTransaction,
type
);
if (type != BudgetTransactionType.Surplus)
{
((BaseViewModel)transactionViewModel).PropertyChanged += OnItemPropertyChanged;
}
return(transactionViewModel);
}
public void Delete(BudgetTransaction transaction)
{
//var tranRepo = new TransactionRepository(_db);
transaction.Status = Models.Base.RecordStatus.Remove;
Update(transaction);
}
public BudgetTransactionListViewModel(
ILoggerFactory loggerFactory,
IAccountService accountService,
IBudgetService budgetService,
IAccountLinkViewModelFactory accountLinkViewModelFactory,
IBudgetTransactionItemViewModelFactory budgetTransactionItemViewModelFactory,
IDeleteConfirmationViewService deleteConfirmationViewService,
int budgetId)
{
m_logger = loggerFactory.CreateLogger <BudgetTransactionListViewModel>();
m_accountService = accountService;
m_budgetService = budgetService;
m_accountLinkViewModelFactory = accountLinkViewModelFactory;
m_budgetTransactionItemViewModelFactory = budgetTransactionItemViewModelFactory;
m_deleteConfirmationViewService = deleteConfirmationViewService;
m_accountLinks = new ObservableCollection <IAccountLinkViewModel>(
m_accountService
.GetAllAsLinks()
.OrderBy(al => al.Name)
.Select(al => m_accountLinkViewModelFactory.Create(al)));
m_budgetId = budgetId;
if (m_budgetId == 0)
{
int firstIncomeAccountId = 0;
int firstAssetAccountId = 0;
int secondAssetAccountId = 0;
IAccountLinkViewModel firstIncomeAccount =
m_accountLinks.FirstOrDefault(al => al.Type == AccountType.Income);
IAccountLinkViewModel firstAssetAccount =
m_accountLinks.FirstOrDefault(al => al.Type == AccountType.Asset);
IAccountLinkViewModel secondAssetAccount =
m_accountLinks.Where(al => al.Type == AccountType.Asset)
.ElementAtOrDefault(1);
if (firstIncomeAccount != null)
{
firstIncomeAccountId = firstIncomeAccount.AccountId;
}
if (firstAssetAccount != null)
{
firstAssetAccountId = secondAssetAccount.AccountId;
}
if (secondAssetAccount != null)
{
secondAssetAccountId = secondAssetAccount.AccountId;
}
var transactions = new List <IBudgetTransactionItemViewModel>();
BudgetTransaction initialTransaction = new BudgetTransaction
{
CreditAccount = new AccountLink {
AccountId = firstIncomeAccountId
},
DebitAccount = new AccountLink {
AccountId = firstAssetAccountId
},
Amount = 0
};
BudgetTransaction surplusTransaction = new BudgetTransaction
{
CreditAccount = new AccountLink {
AccountId = firstAssetAccountId
},
DebitAccount = new AccountLink {
AccountId = secondAssetAccountId
},
Amount = 0
};
transactions.Add(CreateItemViewModel(initialTransaction, BudgetTransactionType.Initial));
transactions.Add(CreateItemViewModel(surplusTransaction, BudgetTransactionType.Surplus));
Transactions = new ObservableCollection <IBudgetTransactionItemViewModel>(transactions);
}
else
{
Budget budget = m_budgetService.Get(m_budgetId);
var transactions = new List <IBudgetTransactionItemViewModel>();
transactions.Add(CreateItemViewModel(budget.InitialTransaction, BudgetTransactionType.Initial));
transactions.AddRange(
budget.Transactions.Select(t => CreateItemViewModel(t, BudgetTransactionType.Regular))
);
transactions.Add(CreateItemViewModel(budget.SurplusTransaction, BudgetTransactionType.Surplus));
Transactions = new ObservableCollection <IBudgetTransactionItemViewModel>(transactions);
}
CalculateSurplusAmount();
}
public Budget GetWithTransaction(string id)
{
Budget budget;
using (SqlConnection conn = new SqlConnection(conn_string))
{
conn.Open();
using (SqlCommand cmd = new SqlCommand(cmd_budget_info, conn))
{
cmd.Parameters.AddWithValue("BudgetID", id);
using (SqlDataReader reader = cmd.ExecuteReader())
{
if (reader.Read())
{
budget = new Budget();
budget.BudgetID = Guid.Parse(id);
budget.AccountID = reader["AccountID"].ToString();
budget.Account = new Account()
{
AccountID = budget.AccountID,
AccountName = reader["AccountName"].ToString()
};
budget.CostCenterID = reader["CostCenterID"].ToString();
budget.CostCenter = new CostCenter()
{
CostCenterID = budget.CostCenterID,
CostCenterName = reader["CostCenterName"].ToString()
};
budget.Year = reader["Year"].ToString();
budget.BudgetAmount = decimal.Parse(reader["BudgetAmount"].ToString());
budget.Status = (BudgetStatus)int.Parse(reader["Status"].ToString());
}
else
{
return(null);
}
}
}
using (SqlCommand cmd = new SqlCommand(cmd_budget_transaction, conn))
{
cmd.Parameters.AddWithValue("BudgetID", id);
using (SqlDataReader reader = cmd.ExecuteReader())
{
budget.BudgetTransactions = new List <BudgetTransaction>();
budget.WithdrawAmount = 0;
while (reader.Read())
{
BudgetTransaction bt = new BudgetTransaction();
bt.BudgetTransactionID = Guid.Parse(reader["BudgetTransactionID"].ToString());
bt.Description = reader["Description"].ToString();
bt.Amount = decimal.Parse(reader["Amount"].ToString());
bt.PreviousAmount = decimal.Parse(reader["PreviousAmount"].ToString());
bt.CreatedAt = DateTime.Parse(reader["CreatedAt"].ToString());
bt.CreatedBy = reader["CreatedBy"].ToString();
bt.ModifiedAt = DateTime.Parse(reader["ModifiedAt"].ToString());
bt.ModifiedBy = reader["ModifiedBy"].ToString();
bt.PaymentID = Guid.Parse(reader["PaymentID"].ToString());
bt.Payment = new Payment()
{
PaymentNo = reader["PaymentNo"].ToString(),
Type = (PaymentType)int.Parse(reader["Type"].ToString()),
RequestBy = reader["RequestBy"].ToString(),
Description = reader["Description"].ToString(),
ContractorID = reader.IsDBNull(reader.GetOrdinal("ContractorID")) ? (Guid?)null : Guid.Parse(reader["ContractorID"].ToString())
};
bt.RemainAmount = budget.BudgetAmount - bt.Amount - bt.PreviousAmount;
budget.BudgetTransactions.Add(bt);
budget.WithdrawAmount += bt.Amount;
}
}
}
conn.Close();
}
budget.RemainAmount = budget.BudgetAmount - budget.WithdrawAmount;
return(budget);
}
public void TestCreateBudgetInDbContext()
{
using (var sqliteMemoryWrapper = new SqliteMemoryWrapper())
{
var currencyFactory = new CurrencyFactory();
Entities.Currency usdCurrencyEntity = currencyFactory.Create(CurrencyPrefab.Usd, true);
currencyFactory.Add(sqliteMemoryWrapper.DbContext, usdCurrencyEntity);
var accountFactory = new AccountFactory();
Entities.Account incomeAccountEntity =
accountFactory.Create(AccountPrefab.Income, usdCurrencyEntity);
Entities.Account checkingAccountEntity =
accountFactory.Create(AccountPrefab.Checking, usdCurrencyEntity);
Entities.Account savingsAccountEntity =
accountFactory.Create(AccountPrefab.Savings, usdCurrencyEntity);
Entities.Account rentPrepaymentAccountEntity =
accountFactory.Create(AccountPrefab.RentPrepayment, usdCurrencyEntity);
Entities.Account rentExpenseAccountEntity =
accountFactory.Create(AccountPrefab.RentExpense, usdCurrencyEntity);
Entities.Account groceriesPrepaymentAccountEntity =
accountFactory.Create(AccountPrefab.GroceriesPrepayment, usdCurrencyEntity);
Entities.Account groceriesExpenseAccountEntity =
accountFactory.Create(AccountPrefab.GroceriesExpense, usdCurrencyEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, incomeAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, checkingAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, savingsAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, rentPrepaymentAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, rentExpenseAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, groceriesPrepaymentAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, groceriesExpenseAccountEntity);
var checkingToRentPrepaymentRelationship = new AccountRelationship
{
SourceAccount = checkingAccountEntity,
DestinationAccount = rentPrepaymentAccountEntity,
Type = AccountRelationshipType.PhysicalToLogical
};
var checkingToGroceriesPrepaymentRelationship = new AccountRelationship
{
SourceAccount = checkingAccountEntity,
DestinationAccount = groceriesPrepaymentAccountEntity,
Type = AccountRelationshipType.PhysicalToLogical
};
var rentPrepaymentToExpenseRelationship = new AccountRelationship
{
SourceAccount = rentPrepaymentAccountEntity,
DestinationAccount = rentExpenseAccountEntity,
Type = AccountRelationshipType.PrepaymentToExpense
};
var groceriesPrepaymentToExpenseRelationship = new AccountRelationship
{
SourceAccount = groceriesPrepaymentAccountEntity,
DestinationAccount = groceriesExpenseAccountEntity,
Type = AccountRelationshipType.PrepaymentToExpense
};
sqliteMemoryWrapper.DbContext.AccountRelationships.Add(checkingToRentPrepaymentRelationship);
sqliteMemoryWrapper.DbContext.AccountRelationships.Add(checkingToGroceriesPrepaymentRelationship);
sqliteMemoryWrapper.DbContext.AccountRelationships.Add(rentPrepaymentToExpenseRelationship);
sqliteMemoryWrapper.DbContext.AccountRelationships.Add(groceriesPrepaymentToExpenseRelationship);
sqliteMemoryWrapper.DbContext.SaveChanges();
var budget = new Budget
{
Name = "Budget",
Period = BudgetPeriod.Fortnightly
};
sqliteMemoryWrapper.DbContext.Budgets.Add(budget);
sqliteMemoryWrapper.DbContext.SaveChanges();
var initialTransaction = new BudgetTransaction
{
CreditAccount = incomeAccountEntity,
DebitAccount = checkingAccountEntity,
Amount = 200m,
IsInitial = true,
Budget = budget
};
var rentTransaction = new BudgetTransaction
{
CreditAccount = checkingAccountEntity,
DebitAccount = rentPrepaymentAccountEntity,
Amount = 100m,
Budget = budget
};
var groceriesTransaction = new BudgetTransaction
{
CreditAccount = checkingAccountEntity,
DebitAccount = groceriesPrepaymentAccountEntity,
Amount = 50m,
Budget = budget
};
var surplusTransaction = new BudgetTransaction
{
CreditAccount = checkingAccountEntity,
DebitAccount = groceriesPrepaymentAccountEntity,
IsSurplus = true,
Budget = budget
};
sqliteMemoryWrapper.DbContext.BudgetTransactions.Add(initialTransaction);
sqliteMemoryWrapper.DbContext.BudgetTransactions.Add(rentTransaction);
sqliteMemoryWrapper.DbContext.BudgetTransactions.Add(groceriesTransaction);
sqliteMemoryWrapper.DbContext.BudgetTransactions.Add(surplusTransaction);
sqliteMemoryWrapper.DbContext.SaveChanges();
List <Account> accounts = sqliteMemoryWrapper.DbContext.Accounts.ToList();
List <AccountRelationship> accountRelationsips = sqliteMemoryWrapper.DbContext.AccountRelationships.ToList();
List <Budget> budgets = sqliteMemoryWrapper.DbContext.Budgets.ToList();
List <BudgetTransaction> budgetTransactions = sqliteMemoryWrapper.DbContext.BudgetTransactions.ToList();
List <Currency> currencies = sqliteMemoryWrapper.DbContext.Currencies.ToList();
List <Transaction> transactions = sqliteMemoryWrapper.DbContext.Transactions.ToList();
Assert.AreEqual(7, accounts.Count);
Assert.AreEqual(4, accountRelationsips.Count);
Assert.AreEqual(1, budgets.Count);
Assert.AreEqual(4, budgetTransactions.Count);
Assert.AreEqual(1, currencies.Count);
Assert.AreEqual(0, transactions.Count);
Assert.AreEqual(budget.Name, budgets[0].Name);
Assert.AreEqual(budget.Period, budgets[0].Period);
Assert.AreEqual(budgetTransactions.Count, budgets[0].Transactions.Count);
}
}
