private void AddNoAccountSelectedError(EditTransactionViewModel vm)
{
if (vm.SelectedAccountId == NotSelected)
{
ModelState.AddModelError("SelectedAccountId", "An account must be selected");
}
}
public async Task <IActionResult> Edit(int id)
{
var transaction = await _transactionsDataService.RetrieveTransactionAsync(id).ConfigureAwait(false);
if (transaction == null)
{
return(NotFound());
}
var viewModel = new EditTransactionViewModel
{
Id = transaction.Id,
Date = transaction.Date,
CategoryId = transaction.CategoryId,
CategoriesList = new SelectList(
await _categoriesDataService.RetrieveCategoriesAsync().ConfigureAwait(false),
nameof(Category.Id),
nameof(Category.Name)),
Memo = transaction.Memo,
Amount = transaction.Amount,
IsCredit = transaction.IsCredit
};
return(View(viewModel));
}
// GET: Edit
// Transaction/Edit/{id}
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Transaction transaction = _db.Transactions.Find(id);
if (transaction == null)
{
return(HttpNotFound());
}
var viewModel = new EditTransactionViewModel();
viewModel.Products = _db.Products.Select(p => new SelectListItem
{
Text = p.Name,
Value = p.ProductId.ToString()
});
viewModel.Customers = _db.Customers.Select(c => new SelectListItem
{
Text = c.FirstName + " " + c.LastName,
Value = c.CustomerId.ToString()
});
viewModel.TransactionId = transaction.TransactionId;
viewModel.CustomerId = transaction.CustomerId;
viewModel.ProductId = transaction.ProductId;
return(View(viewModel));
}
public ActionResult EditTransaction(EditTransactionViewModel vm, bool isDone = false)
{
@ViewBag.Title = "Edit Transaction";
if (vm.FindingBudgetItems)
{
return(FindBudgetItemsAndReturn(vm));
}
AddNoAccountSelectedError(vm);
if (!ModelState.IsValid)
{
return(MapEditTransactionViewModelAndReturn(vm));
}
var account = FinancialPlannerRepository.GetAccounts().FirstOrDefault(m => m.Id == vm.SelectedAccountId);
var transaction = FinancialPlannerRepository.GetTransactions().FirstOrDefault(m => m.Id == vm.AccountTransactionId);
if (transaction == null)
{
return(View("Error"));
}
//think about consolidating this
var oldBudgetItemId = transaction.BudgetItemId;
var oldExpenseId = transaction.ExpenseId;
transaction.AccountId = vm.SelectedAccountId;
FinancialPlannerAccountService.EditTransaction(vm);
FinancialPlannerAccountService.AdjustOldBudgetItemBalance(oldBudgetItemId);
if (oldBudgetItemId != vm.SelectedBudgetItemId)
{
FinancialPlannerAccountService.AdjustNewBudgetItemBalance(vm);
}
AdjustAccountTransactionBalances(vm, account);
AdjustExpenseBalances(vm, oldExpenseId);
AdjustAccountAmounts(vm, account);
@ViewBag.Title = "Edit Transaction";
FinancialPlannerAccountService.MapEditTransactionViewModel(vm, User.Identity.Name);
if (isDone)
{
return(RedirectToAction("Index", new { accountId = transaction.AccountId }));
}
else
{
return(PartialView("EditTransaction", vm));
}
}
public void AdjustNewBudgetItemBalance(EditTransactionViewModel vm)
{
var budgetItem = FinancialPlannerRepository.GetBudgetItems().FirstOrDefault(m => m.Id == vm.SelectedBudgetItemId);
if (budgetItem != null)
{
EditBudgetItem(budgetItem);
}
}
private ActionResult FindBudgetItemsAndReturn(EditTransactionViewModel vm)
{
FinancialPlannerAccountService.MapEditTransactionViewModel(vm, User.Identity.Name);
ModelState.Remove("FindingBudgetItems");
vm.FindingBudgetItems = false;
return(PartialView("EditTransaction", vm));
}
public EditTransactionPage(Account account, Transaction Transaction) : this()
{
var viewModel = new EditTransactionViewModel(account, Transaction);
BindingContext = viewModel;
viewModel.OnTransactionUpdated += ViewModel_OnTransactionUpdated;
viewModel.OnError += ViewModel_OnError;
viewModel.OnCancel += ViewModel_OnCancel;
}
private void AdjustBudgetItemBalance(EditTransactionViewModel vm)
{
var budgetItem =
FinancialPlannerRepository.GetBudgetItems().FirstOrDefault(m => m.Id == vm.SelectedBudgetItemId);
if (budgetItem != null)
{
FinancialPlannerAccountService.AdjustBudgetItemBalance(budgetItem, vm);
}
}
private void SetSelectedExpenseForViewModel(Transaction transaction, EditTransactionViewModel vm)
{
var selectedExpense =
FinancialPlannerRepository.GetExpenses().FirstOrDefault(m => m.Id == transaction.ExpenseId);
if (selectedExpense != null)
{
vm.SelectedExpenseId = selectedExpense.Id;
}
}
public static void SetCategoryDropDownList(EditTransactionViewModel transactionViewModel, HttpRequestBase request)
{
var categories = HouseholdHelpers.GetCategories(transactionViewModel.HouseholdId, request);
transactionViewModel.Categories = categories.Select(p =>
new SelectListItem()
{
Text = p.Name,
Value = p.Id.ToString()
}).ToList();
}
public EditTransactionViewModel TransactionMasterAndDetailById(int transactionMasterId, int insttituteId)
{
if (transactionMasterId == 0)
{
return(new EditTransactionViewModel());
}
DataSet set1 = this.accountsAppAPI.TransactionMasterAndDetailById(this.sKey, insttituteId, transactionMasterId);
EditTransactionViewModel model = set1.Tables[0].DataTableToList <EditTransactionViewModel>().FirstOrDefault <EditTransactionViewModel>();
model.ledgerViewModels = set1.Tables[1].DataTableToList <EditTransactionLedgerViewModel>();
return(model);
}
public EditTransactionViewModel MapEditTransactionViewModel(string username)
{
var accounts = FinancialPlannerRepository.GetAccounts()
.Where(m => m.UserName == username);
var vm = new EditTransactionViewModel
{
Accounts = SetViewModelsService.SetAccountViewModels(accounts)
};
return(vm);
}
public ActionResult EditTransaction(int id, EditTransactionViewModel formData)
{
var httpClient = new HttpClient();
httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {ViewBag.Token}");
var url_Category = $"http://localhost:55336/api/Category/GetAllCategory/{formData.HouseHoldId}";
var response_Category = httpClient.GetAsync(url_Category).Result;
var data_Category = response_Category.Content.ReadAsStringAsync().Result;
var categoryNameList = JsonConvert.DeserializeObject <List <CategoryNameList> >(data_Category);
formData.CategoryNameList = categoryNameList;
if (!ModelState.IsValid)
{
return(View(formData));
}
var parameters = new List <KeyValuePair <string, string> >();
parameters.Add(new KeyValuePair <string, string>("Name", formData.Name));
parameters.Add(new KeyValuePair <string, string>("Description", formData.Description));
parameters.Add(new KeyValuePair <string, string>("Date", formData.Date.ToString()));
parameters.Add(new KeyValuePair <string, string>("CategoryId", formData.CategoryId.ToString()));
parameters.Add(new KeyValuePair <string, string>("Amount", formData.Amount.ToString()));
var enCodeParameters = new FormUrlEncodedContent(parameters);
var url = $"http://localhost:55336/api/Transaction/Update/{id}";
var response = httpClient.PutAsync(url, enCodeParameters).Result;
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
TempData["Message"] = "Transaction was edited successfully";
return(RedirectToAction("ListOfTransaction", "Transaction", new { id = formData.BankAccountId, houseHoldId = formData.HouseHoldId }));
}
else if (response.StatusCode == System.Net.HttpStatusCode.BadRequest)
{
var data = response.Content.ReadAsStringAsync().Result;
var result = JsonConvert.DeserializeObject <APIErrorData>(data);
foreach (var ele in result.ModelState)
{
ModelState.AddModelError("", ele.Value[0].ToString());
}
return(View(formData));
}
else
{
return(RedirectToAction("Error", "Home"));
}
}
public void MapEditTransactionViewModel(EditTransactionViewModel vm, string username)
{
var accounts = FinancialPlannerRepository.GetAccounts().Where(m => m.UserName == username);
var budgets = FinancialPlannerRepository.GetBudgets().Where(m => m.Username == username);
var expenses = FinancialPlannerRepository.GetExpenses().Where(m => m.Username == username);
var budgetItems =
FinancialPlannerRepository.GetBudgetItems().Where(m => m.BudgetId == vm.SelectedBudgetId);
vm.BudgetItems = SetViewModelsService.SetBudgetItemViewModels(budgetItems);
vm.Accounts = SetViewModelsService.SetAccountViewModels(accounts);
vm.Budgets = SetViewModelsService.SetBudgetViewModels(budgets);
vm.Expenses = SetViewModelsService.SetExpenseViewModels(expenses);
}
public ActionResult Edit(EditTransactionViewModel transactionViewModel)
{
if (!ModelState.IsValid)
{
TransactionHelpers.SetCategoryDropDownList(transactionViewModel, Request);
if (transactionViewModel.Categories is null)
{
TempData.Add("Message", "Error: Categories missing");
TempData.Add("MessageColour", "danger");
return(RedirectToAction("Index", "Household"));
}
return(View(transactionViewModel));
}
var url = $"{ProjectConstants.APIURL}/api/transaction/edit/{transactionViewModel.Id}";
var parameters = new List <KeyValuePair <string, string> >
{
new KeyValuePair <string, string>("Title", transactionViewModel.Title),
new KeyValuePair <string, string>("Description", transactionViewModel.Description),
new KeyValuePair <string, string>("Amount", transactionViewModel.Amount.ToString()),
new KeyValuePair <string, string>("Date", transactionViewModel.Date.ToString()),
new KeyValuePair <string, string>("CategoryId", transactionViewModel.CategoryId.ToString()),
};
var encodedParameters = new FormUrlEncodedContent(parameters);
var response = HttpClientContext.httpClient.PostAsync(url, encodedParameters).Result;
if (response.IsSuccessStatusCode)
{
TempData.Add("Message", $"Transaction '{transactionViewModel.Title}' Edited!");
return(RedirectToAction("HouseholdTransactions", "Transaction", new { Id = transactionViewModel.HouseholdId }));
}
else
{
ErrorHelpers.HandleResponseErrors(response, TempData, ModelState);
TransactionHelpers.SetCategoryDropDownList(transactionViewModel, Request);
if (transactionViewModel.Categories is null)
{
TempData.Add("Message", "Error: Categories missing");
TempData.Add("MessageColour", "danger");
return(RedirectToAction("Index", "Household"));
}
return(View(transactionViewModel));
}
}
public ActionResult Edit(int?id, int houseHoldId)
{
var cookie = Request.Cookies["MyCookie"];
if (cookie == null)
{
return(RedirectToAction("Login", "Account"));
}
var httpClient = new HttpClient();
httpClient.DefaultRequestHeaders.Add("Authorization",
$"Bearer {cookie.Value}");
string url = $"http://localhost:64310/api/Transaction/Transaction/{id}";
var response = httpClient
.GetAsync(url)
.Result;
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
var data = response.Content.ReadAsStringAsync().Result;
var result = JsonConvert.DeserializeObject <TransactionViewModel>(data);
var editViewModel = new EditTransactionViewModel();
string url1 = $"http://localhost:64310/api/Category/HouseHoldCategories/{houseHoldId}";
var response1 = httpClient
.GetAsync(url1)
.Result;
var data1 = response1.Content.ReadAsStringAsync().Result;
var result1 = JsonConvert.DeserializeObject <List <CategoryViewModel> >(data1);
editViewModel.Title = result.Title;
editViewModel.Description = result.Description;
editViewModel.TransactionDate = result.TransactionDate;
editViewModel.Void = result.IsVoided;
editViewModel.Amount = result.Amount;
ViewBag.id = id;
ViewBag.bankAccountId = result.BankAccountId;
editViewModel.Category = new SelectList(result1, nameof(CategoryViewModel.Id), nameof(CategoryViewModel.Name));
ViewBag.houseHoldId = houseHoldId;
return(View(editViewModel));
}
else
{
return(RedirectToAction("Index", "Home"));
}
}
private void AdjustAccountAmounts(EditTransactionViewModel vm, Account account)
{
FinancialPlannerAccountService.AdjustAccountAmount(account);
if (vm.OldAccountId != vm.SelectedAccountId && vm.OldAccountId != 0)
{
var oldAccount = FinancialPlannerRepository.GetAccounts().FirstOrDefault(m => m.Id == vm.OldAccountId);
if (oldAccount != null)
{
FinancialPlannerAccountService.AdjustAccountAmount(oldAccount);
}
}
}
public void AdjustBudgetItemBalance(BudgetItem budgetItem, EditTransactionViewModel vm)
{
budgetItem.Balance = vm.IsWithdrawal
? budgetItem.Balance - vm.Amount
: budgetItem.Balance + vm.Amount;
if (budgetItem.Balance > budgetItem.Amount)
{
budgetItem.Amount = budgetItem.Balance;
}
FinancialPlannerRepository.EditBudgetItem(budgetItem);
FinancialPlannerRepository.Save();
}
public void AdjustAccountBalance(Account account, EditTransactionViewModel vm)
{
if (vm.IsWithdrawal)
{
account.Amount = account.Amount - vm.Amount;
}
else
{
account.Amount = account.Amount + vm.Amount;
}
FinancialPlannerRepository.EditAccount(account);
FinancialPlannerRepository.Save();
}
public ActionResult EditTransaction(EditTransactionViewModel model)
{
var transaction = _manager.GetTransaction(model.Id);
if (ModelState.IsValid)
{
transaction.Date = model.Date;
transaction.Type = model.Type;
transaction.Amount = model.Amount;
transaction.Description = model.Description;
transaction.CategoryId = model.CategoryId;
transaction.IsReconciled = model.IsReconciled;
_manager.EditTransaction(transaction);
}
return(RedirectToAction("Details", new { id = transaction.BankAccountId }));
}
public TransactionsViewModel(string label, ViewParameter parameter, EditTransactionViewModel editTransactionViewModel)
: base(label, parameter)
{
Options.AllowStockSelection = true;
Options.DateSelection = DateSelectionType.Range;
_Heading = label;
Transactions = new ObservableCollection <TransactionViewItem>();
TransactionCommands = new ObservableCollection <RelayUICommand>();
_EditTransactionViewModel = editTransactionViewModel;
EditTransactionCommand = new RelayCommand <Guid>(EditTransaction);
CreateTransactionCommand = new RelayCommand <TransactionType>(CreateTransaction);
}
private void AdjustAccountTransactionBalances(EditTransactionViewModel vm, Account account)
{
var originalAccount = FinancialPlannerRepository.GetAccounts().FirstOrDefault(m => m.Id == vm.OldAccountId);
FinancialPlannerAccountService.AdjustTransactionBalances(account);
if (originalAccount != null && account != null && (account.Amount != originalAccount.Amount))
{
var oldAccount = FinancialPlannerRepository.GetAccounts().FirstOrDefault(m => m.Id == vm.OldAccountId);
if (oldAccount != null && account.Id != oldAccount.Id)
{
FinancialPlannerAccountService.AdjustTransactionBalances(oldAccount);
}
}
}
private void AdjustExpenseBalances(EditTransactionViewModel vm, int?oldExpenseId)
{
var expense = FinancialPlannerRepository.GetExpenses().FirstOrDefault(m => m.Id == vm.SelectedExpenseId);
if (expense != null)
{
FinancialPlannerAccountService.AdjustExpenseBalance(expense);
}
var oldExpense = FinancialPlannerRepository.GetExpenses().FirstOrDefault(m => m.Id == oldExpenseId);
if (oldExpense != null)
{
FinancialPlannerAccountService.AdjustExpenseBalance(oldExpense);
}
}
public ActionResult Edit(EditTransactionViewModel viewModel)
{
if (ModelState.IsValid)
{
Transaction transaction = _db.Transactions.Find(viewModel.TransactionId);
transaction.CustomerId = viewModel.CustomerId;
transaction.ProductId = viewModel.ProductId;
_db.Entry(transaction).State = EntityState.Modified;
_db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(viewModel));
}
private void SetBudgetItemsForViewModel(Transaction transaction, EditTransactionViewModel vm)
{
var selectedBudgetItem =
FinancialPlannerRepository.GetBudgetItems().FirstOrDefault(m => m.Id == transaction.BudgetItemId);
if (selectedBudgetItem != null)
{
var budgetItems =
FinancialPlannerRepository.GetBudgetItems()
.Where(m => m.BudgetId == selectedBudgetItem.BudgetId)
.ToList();
vm.BudgetItems = SetViewModelsService.SetBudgetItemViewModels(budgetItems);
vm.SelectedBudgetId = selectedBudgetItem.BudgetId;
vm.SelectedBudgetItemId = transaction.BudgetItemId;
}
}
public ActionResult AddTransaction(EditTransactionViewModel vm, bool isDone = false)
{
ViewBag.Title = "Add Transaction";
var transaction = new Transaction();
if (vm.FindingBudgetItems)
{
return(FindBudgetItemsAndReturn(vm));
}
AddNoAccountSelectedError(vm);
if (!ModelState.IsValid)
{
return(MapEditTransactionViewModelAndReturn(vm));
}
if (vm.AccountTransactionId == 0)
{
var account = FinancialPlannerRepository.GetAccounts().FirstOrDefault(m => m.Id == vm.SelectedAccountId);
if (account == null)
{
return(PartialView("Error"));
}
transaction = AdjustBalancesForTransaction(vm, account);
ModelState.Remove("AccountTransactionId");
FinancialPlannerAccountService.MapEditTransactionViewModel(vm, User.Identity.Name);
vm.AccountTransactionId = transaction.Id;
ViewBag.Title = "Edit Transaction";
if (isDone)
{
return(RedirectToAction("Index", new { accountId = transaction.AccountId }));
}
return(PartialView("EditTransaction", vm));
}
return(isDone ? RedirectToAction("Index", new { accountId = transaction.AccountId }) : EditTransaction(vm));
}
public void EditTransaction(EditTransactionViewModel vm)
{
var transaction = FinancialPlannerRepository.GetTransactions().FirstOrDefault(m => m.Id == vm.AccountTransactionId);
if (transaction != null)
{
transaction.Amount = vm.Amount;
transaction.Name = vm.Name;
transaction.PaymentDate = vm.PaymentDate;
transaction.IsWithdrawal = vm.IsWithdrawal;
transaction.BudgetItemId = vm.SelectedBudgetItemId;
transaction.AccountId = vm.SelectedAccountId;
transaction.ExpenseId = vm.SelectedExpenseId;
FinancialPlannerRepository.EditTransaction(transaction);
FinancialPlannerRepository.Save();
}
}
public Transaction AddTransaction(Account account, EditTransactionViewModel vm)
{
var newTransaction = new Transaction
{
Name = vm.Name,
Amount = vm.Amount,
IsWithdrawal = vm.IsWithdrawal,
AccountId = vm.SelectedAccountId != -1 ? vm.SelectedAccountId : 0,
PaymentDate = vm.PaymentDate,
Balance = account.Amount,
BudgetItemId = vm.SelectedBudgetItemId,
ExpenseId = vm.SelectedExpenseId != -1 ? vm.SelectedExpenseId : 0
};
FinancialPlannerRepository.AddTransaction(newTransaction);
FinancialPlannerRepository.Save();
return(newTransaction);
}
public EditTransactionViewModel MapEditTransactionViewModelForEdit(int id, int accountId, string username)
{
var transaction = FinancialPlannerRepository.GetTransactions()
.FirstOrDefault(m => m.Id == id);
if (transaction == null)
{
return(null);
}
var accounts = FinancialPlannerRepository.GetAccounts()
.Where(m => m.UserName == username);
var budgets = FinancialPlannerRepository.GetBudgets()
.Where(m => m.Username == username).ToList();
var expenses = FinancialPlannerRepository.GetExpenses().Where(m => m.Username == username);
var vm = new EditTransactionViewModel
{
Accounts = SetViewModelsService.SetAccountViewModels(accounts),
AccountTransactionId = transaction.Id,
Amount = transaction.Amount,
IsWithdrawal = transaction.IsWithdrawal,
Name = transaction.Name,
PaymentDate = transaction.PaymentDate,
SelectedAccountId = accountId != 0 ? accountId : 0,
OldAccountId = accountId != 0 ? accountId : 0,
WasWithdrawal = transaction.IsWithdrawal,
OldAmount = transaction.Amount,
Budgets = SetViewModelsService.SetBudgetViewModels(budgets),
Expenses = SetViewModelsService.SetExpenseViewModels(expenses)
};
if (transaction.BudgetItemId != null && transaction.BudgetItemId > 0)
{
SetBudgetItemsForViewModel(transaction, vm);
}
SetSelectedExpenseForViewModel(transaction, vm);
return(vm);
}
public PartialViewResult EditTransactionModal(int id)
{
var householdId = User.Identity.GetHouseholdId().Value;
var availableCategories = _categoryManager.GetAll(householdId).ToList();
var transaction = _manager.GetTransaction(id);
var model = new EditTransactionViewModel
{
Id = transaction.Id,
Date = transaction.Date,
Type = transaction.Type,
Amount = transaction.Amount,
Description = transaction.Description,
CategoryId = transaction.CategoryId,
IsReconciled = transaction.IsReconciled,
CategorySelectList = new SelectList(availableCategories, "Id", "Name", transaction.CategoryId)
};
return(PartialView(model));
}
