public ActionResult Create(TransactionCreateViewModel viewModel) { var status = false; if (ModelState.IsValid && Request.IsAjaxRequest()) { var bankAccount = _readBankAccount.GetBankAccountById(viewModel.BankAccountId); var binder = new FromTransactionCreateViewModel(); var transaction = binder.GetTransaction(viewModel, bankAccount); _writeTransaction.Create(transaction); status = true; return(new JsonResult() { Data = new { status = status } }); } else { return(new JsonResult() { Data = new { status = status } }); } }
//GET: Transaction/Json Select Lists public ActionResult JsonSelect() { int houseId = (int)User.Identity.GetHouseholdId(); var bankAccts = db.BankAccts.Where(b => b.householdId == houseId).ToList(); var catagories = db.TransactionCatagory.Where(c => c.householdId == houseId || c.householdId == null).ToList(); var budgets = db.Budgets.Where(b => b.householdId == houseId).ToList(); var model = new TransactionCreateViewModel(); model.bankAccount = bankAccts.Select(b => new SelectListItem { Value = b.id.ToString(), Text = b.title }); model.transactionCatagory = catagories.Select(b => new SelectListItem { Value = b.id.ToString(), Text = b.name }); model.transactionType = db.TransactionType.Select(b => new SelectListItem { Value = b.id.ToString(), Text = b.name }); model.frequency = db.Frequencies.Select(f => new SelectListItem { Value = f.id.ToString(), Text = f.name }); model.budget = budgets.Select(b => new SelectListItem { Value = b.id.ToString(), Text = b.title }); return(Json(model, JsonRequestBehavior.AllowGet)); }
public ActionResult Index(int?id) { if (id == null) { return(RedirectToAction("Index", "Errors", new { errorMessage = "Account not found" })); } Account account = db.Accounts.Find(id); if (account == null) { return(RedirectToAction("Index", "Errors", new { errorMessage = "Account not found" })); } //check if the user is authorized to view this account var helper = new AccountUserHelper(); var user = User.Identity.GetUserId(); if (helper.CanUserAccessAccount(user, (int)id) == false) { return(RedirectToAction("Index", "Errors", new { errorMessage = "Not authorized" })); } var createTransactionModel = new TransactionCreateViewModel(); createTransactionModel.AccountId = account.Id; var categories = db.Categories.ToList(); createTransactionModel.CategoryList = new SelectList(categories, "Id", "Name"); var householdId = User.Identity.GetHouseholdId(); var householdUsers = db.Users.Where(x => x.HouseholdId == (int)householdId).ToList(); createTransactionModel.HouseholdUsersList = new SelectList(householdUsers, "Id", "UserName"); //pass a model to create a new transaction through the ViewBag ViewBag.CreateModel = createTransactionModel; //get all the transactions for this account var transactions = db.Transactions.Where(x => x.AccountId == id).ToList(); //transform the transactions so we can show them in the index page var transactionsToShow = new List <TransactionsIndexViewModel>(); foreach (var t in transactions) { var transToShow = new TransactionsIndexViewModel(t); transactionsToShow.Add(transToShow); } //pass the account Id to the model ViewBag.AccountId = account.Id; //get the account name and put it in the ViewBag ViewBag.AccountName = account.Name; //update the account balance account.UpdateAccountBalance(); //update the reconciled balance account.UpdateReconciledAccountBalance(); //pass the balances in the ViewBag ViewBag.Balance = account.Balance; ViewBag.Reconciled = account.ReconciledBalance; ViewBag.StartingBalance = account.StartingBalance; return(View(transactionsToShow)); }
public async Task <ActionResult> Create(TransactionCreateViewModel vm) { BankAccount bankAccount = await db.BankAccounts.FirstOrDefaultAsync(x => x.Id == vm.BankAccount_Id); if (bankAccount == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } if (ModelState.IsValid) { SignTransactionAmount(vm); Transaction transaction = new Transaction { Id = Guid.NewGuid(), Date = DateTimeOffset.Now, BankAccount = bankAccount, PreviousBalance = bankAccount.Balance, Amount = vm.Amount, SignedAmount = vm.SignedAmount, Description = vm.Description, TransactionType = vm.TransactionType, }; db.Transactions.Add(transaction); await db.SaveChangesAsync(); await HandleTransactionAsync(vm); return(RedirectToAction("Index", "Transaction", new { acctId = vm.BankAccount_Id })); } return(View(vm.BankAccount_Id)); }
public async Task <TransactionIndexItemViewModel> PostTransaction(TransactionCreateViewModel model) { model.CreatorID = User.Identity.GetUserId <int>(); var result = await _apiTransactionService.Create(model); return(result); }
public TransactionCreateViewModel BuildTransactionCreateViewModel(int userId, int?projectId) { IList <Domains.DataObject.Project> projects = null; if (!projectId.HasValue) { projects = _dbContext.Projects.Where(x => x.CreatorID == userId).ToList(); } else { projects = _dbContext.Projects.Where(x => x.ProjectID == projectId.Value).ToList(); } var transactionTypes = _dbContext.TransactionTypes.Where(x => x.CreatorID == userId || x.CreatorID == null); var paymentMethods = _dbContext.PaymentMethods.Where(x => x.CreatorID == userId || x.CreatorID == null); var model = new TransactionCreateViewModel { Date = DateTime.Now, ProjectID = projectId, Projects = projects, TransactionTypes = transactionTypes, PaymentMethods = paymentMethods }; return(model); }
public ActionResult Create(TransactionCreateViewModel viewModel) { try { if (ModelState.IsValid) { using (var basket = BasketWrapper.CreateNewByIdentity(dataContextFactory)) { basket.AddItems(viewModel.Transaction.SelectedSKUGuids.Select(x => x.ToString()).ToList()); basket.Transaction.PurchaserEmail = "n/a"; basket.Transaction.PurchaserName = "n/a"; basket.ExecuteCreate(); return(RedirectToAction("Checkout", new { key = basket.Transaction.TransactionId.ToString().EncryptUrl() })); } } else { return(View(viewModel)); } } catch { throw; } }
public void TestTransactionCreateViewModelCancel() { ILoggerFactory loggerFactory = new LoggerFactory(); using (var sqliteMemoryWrapper = new SqliteMemoryWrapper()) { var currencyFactory = new CurrencyFactory(); var 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); accountFactory.Add(sqliteMemoryWrapper.DbContext, incomeAccountEntity); accountFactory.Add(sqliteMemoryWrapper.DbContext, checkingAccountEntity); var accountService = new AccountService( loggerFactory, sqliteMemoryWrapper.DbContext); var transactionService = new TransactionService( loggerFactory, sqliteMemoryWrapper.DbContext); var mockViewModelFactory = new Mock <IAccountLinkViewModelFactory>(); mockViewModelFactory .Setup(f => f.Create(It.IsAny <AccountLink>())) .Returns((AccountLink accountLink) => { return(new AccountLinkViewModel( loggerFactory, accountLink)); }); var hint = new Transaction { CreditAccount = accountService.GetAsLink(incomeAccountEntity.AccountId), DebitAccount = accountService.GetAsLink(checkingAccountEntity.AccountId), Amount = 10m, At = new DateTime(2018, 1, 1, 9, 0, 0) }; var viewModel = new TransactionCreateViewModel( loggerFactory, accountService, transactionService, mockViewModelFactory.Object, hint ); viewModel.CancelCommand.Execute(this); List <Transaction> transactions = transactionService.GetAll().ToList(); Assert.AreEqual(0, transactions.Count); } }
/// <summary> /// Updates bank balanced based on new transactions signed amount /// </summary> /// <param name="vm"></param> /// <returns></returns> public async Task <ActionResult> HandleTransactionAsync(TransactionCreateViewModel vm) { BankAccount bankAccount = await db.BankAccounts.FirstOrDefaultAsync(x => x.Id == vm.BankAccount_Id); bankAccount.Balance += vm.SignedAmount; db.Entry(bankAccount).State = EntityState.Modified; await db.SaveChangesAsync(); return(null); }
public async Task <TransactionIndexItemViewModel> Create(TransactionCreateViewModel model) { var transaction = Mapper.Map <Domains.DataObject.Transaction>(model); _dbContext.Transactions.Add(transaction); await _dbContext.SaveChangesAsync(); var result = Mapper.Map <TransactionIndexItemViewModel>(transaction); return(result); }
public TransactionCreateViewModel GetViewModel(Model.BankAccount bankAccount, CurrencyLogic currencyLogic) { var viewModel = new TransactionCreateViewModel { AccountBalance = bankAccount.Balance, Currency = currencyLogic.GetCurrencyIconById(bankAccount.Currency), BankAccountId = bankAccount.Id, UserId = bankAccount.User.Id }; return(viewModel); }
public ServiceResult Create(TransactionCreateViewModel model) { var entity = AutoMapper.Mapper.Map <Domain.Entities.Transaction>(model); _context.Add(entity); var result = _context.SaveChanges(); if (result > 0) { return(ServiceResult.Okay()); } return(ServiceResult.Error()); }
public void CreateTransaction(TransactionCreateViewModel model) { var transaction = Mapper.Map <Domains.DataObject.Transaction>(model); _dbContext.Transactions.Add(transaction); if (transaction.ProjectID.HasValue) { var project = _dbContext.Projects.Find(transaction.ProjectID.Value); project.ActualValue = project.ActualValue + (transaction.Income ? 1 : -1 * transaction.Amount); } _dbContext.SaveChanges(); }
public virtual async Task <ActionResult> Create(TransactionCreateViewModel model) { if (!ModelState.IsValid) { return(View(model)); } model.CreatorID = await GetCurrentUserIdAsync(); _transactionService.CreateTransaction(model); return(RedirectToAction(MVC.Project.ActionNames.Index)); }
/// <summary> /// Create a single Transaction /// </summary> /// <returns>Create transaction view</returns> public ActionResult Create() { using (var context = dataContextFactory.CreateByUser()) { var skus = context.SKUs.OrderBy(s => s.SkuCode).ToList(); var viewModel = new TransactionCreateViewModel(new Transaction { CreatedDateTime = DateTime.Now }, skus); return(View(viewModel)); } }
public ActionResult Create(int?budgetId) { var user = db.Users.Find(User.Identity.GetUserId()); var viewModel = new TransactionCreateViewModel(); if (budgetId != null) { viewModel.Budget = db.Budgets.Find(budgetId); } viewModel.User = user; viewModel.Group = user.Group; viewModel.DateTime = DateTime.Now.ToString("MM/dd/yyyy"); return(View(viewModel)); }
public Model.Transaction GetTransaction(TransactionCreateViewModel viewmodel, Model.BankAccount bankAccount) { var transaction = new Model.Transaction { Id = Guid.NewGuid().ToString(), Name = viewmodel.Name, Amount = viewmodel.Balance, AccountBalance = viewmodel.AccountBalance, SetDate = viewmodel.SetDate, Description = viewmodel.Description, BankAccount = bankAccount }; return(transaction); }
public void ConstructorTest() { var viewModel = new TransactionCreateViewModel(_storages); Assert.IsNotNull(viewModel.ChildrenTransactions); Assert.AreEqual(0, viewModel.Total); Assert.AreEqual(0, viewModel.Weight); Assert.IsFalse(viewModel.IsComplexTransaction); Assert.IsFalse(viewModel.IsExistingTransaction); Assert.IsNull(viewModel.Transaction); Assert.IsNotNull(viewModel.Categories); Assert.IsNotNull(viewModel.Accounts); Assert.IsNotNull(viewModel.Transactions); }
/// <summary> /// Assigns appropriate sign to transaction amount based on transaction and bank account type /// </summary> /// <param name="vm"></param> /// <returns></returns> public TransactionCreateViewModel SignTransactionAmount(TransactionCreateViewModel vm) { string tType = vm.TransactionType.ToString(); string aType = vm.AccountType.ToString(); if ((tType == "Withdrawal" && aType == "Debit") || (tType == "Deposit" && aType == "Credit")) { vm.SignedAmount = vm.Amount * -1; } else { vm.SignedAmount = vm.Amount; } return(vm); }
public ActionResult AddTransactions(TransactionCreateViewModel model) { try { transactionService.Add(model); }catch (Exception ex) { Elmah.ErrorSignal.FromCurrentContext().Raise(ex); return(Json(new JsonMessage() { Status = JsonResultStatus.Fail, Message = "Adding failure" }, JsonRequestBehavior.AllowGet)); } return(Json(new JsonMessage() { Status = JsonResultStatus.Success, Message = "Adding successfully" }, JsonRequestBehavior.AllowGet)); }
public void ConstructorWithTransactionTest() { var viewModel = new TransactionCreateViewModel(_storages, _transaction); Assert.IsNotNull(viewModel.ChildrenTransactions); Assert.AreEqual(22m, viewModel.Total); Assert.AreEqual(0.451m, viewModel.Weight); Assert.IsFalse(viewModel.IsComplexTransaction); Assert.IsFalse(viewModel.IsExistingTransaction); Assert.IsNull(viewModel.Transaction); Assert.IsNotNull(viewModel.Categories); Assert.IsNotNull(viewModel.Accounts); Assert.IsNotNull(viewModel.Transactions); Assert.AreEqual(_category, viewModel.Category); Assert.AreEqual(_account, viewModel.Account); Assert.AreEqual(_transaction.Name, viewModel.Name); }
// GET: Transaction/Create public async Task <ActionResult> Create(Guid?acctId) { if (acctId == null) { return(RedirectToAction("Index", "BankAccount")); } BankAccount bankAccount = await db.BankAccounts.FindAsync(acctId); if (bankAccount == null) { return(HttpNotFound()); } TransactionCreateViewModel transaction = new TransactionCreateViewModel(); transaction.BankAccount_Id = (Guid)acctId; transaction.AccountType = bankAccount.AccountType; ViewBag.Name = bankAccount.Name; return(View(transaction)); }
public async Task <IHttpActionResult> CreateTransaction(TransactionCreateViewModel model) { try { var transactionApi = new TransactionApi(); var UserManager = Request.GetOwinContext().GetUserManager <ApplicationUserManager>(); var user = await UserManager.FindByNameAsync(model.Username); var userId = user.Id; model.TransactionDate = DateTime.Now; model.AspNetUserId = userId; model.EndTime = model.TransactionDate.AddHours(model.Duration); var transaction = transactionApi.CreateTransaction(model); var parkingLot = (new ParkingLotApi()).Get(model.ParkingLotId); transaction.TransactionCode = parkingLot.Address + transaction.Id + ""; transactionApi.Edit(transaction.Id, transaction); TransactionCreateReturnViewModel result = new TransactionCreateReturnViewModel() { Id = transaction.Id, Amount = transaction.Amount, AspNetUserId = transaction.AspNetUserId, CarParkId = transaction.CarParkId, EndTime = transaction.EndTime, LongEndTime = transaction.EndTime.Value.Ticks, ParkingLotId = transaction.ParkingLotId, Status = transaction.Status, TransactionCode = transaction.TransactionCode, TransactionDate = transaction.TransactionDate, }; return(Json(new ResultModel { obj = result, success = true, })); } catch (Exception ex) { return(Json(new ResultModel { success = false, })); } }
public async Task <IActionResult> AddTransaction([FromRoute] Guid accountId, [FromBody] TransactionCreateViewModel transactionCreateViewModel) { if (!ModelState.IsValid) { return(BadRequest()); } try { var transactionId = await _transactionsService.AppendTransaction(accountId, transactionCreateViewModel.Amount); return(Ok(transactionId)); } catch (Exception e) { Console.WriteLine(e); throw; } }
public ActionResult Create([Bind(Include = "AccountId,Description,DateSpent,Amount,Type,SelectedCategory,SelectedUser,ReconciledAmount")] TransactionCreateViewModel model) { if (ModelState.IsValid) { var transaction = new Transaction(); transaction.AccountId = model.AccountId; transaction.Description = model.Description; transaction.DateEntered = DateTime.Now; transaction.DateSpent = model.DateSpent; transaction.Amount = model.Amount; transaction.Type = model.Type; transaction.CategoryId = model.SelectedCategory; transaction.EnteredById = User.Identity.GetUserId(); transaction.SpentById = model.SelectedUser; if (model.Amount == model.ReconciledAmount) { transaction.IsReconciled = true; } else { transaction.IsReconciled = false; } transaction.ReconciledAmount = model.ReconciledAmount; db.Transactions.Add(transaction); db.SaveChanges(); var account = db.Accounts.Find(model.AccountId); //update the account balance account.UpdateAccountBalance(); //update the reconciled balance account.UpdateReconciledAccountBalance(); return(RedirectToAction("Index", new { id = model.AccountId })); } return(RedirectToAction("Index", new { id = model.AccountId })); }
public bool Add(TransactionCreateViewModel model) { if (model.Transactions != null && model.Transactions.Count() > 0) { foreach (var transaction in model.Transactions) { transactionRepository.Insert(new Transaction() { CustomerID = model.CustomerId, Error = transaction.Error, Description = transaction.DeviceDescription, TypeID = transaction.CategoryId, RecievedDate = DateTime.Now, StatusID = (int)entity.Enums.TransactionStatus.NotFix, }); } unitOfWork.SaveChanges(); return(true); } else { return(false); } }
public ActionResult Create([Bind(Include = "Description,Amount,Type,AccountId,BudgetCategoryId,Date")] TransactionCreateViewModel vm) { Household userHousehold = db.Households.Find(Convert.ToInt32(User.Identity.GetHouseholdId())); if (ModelState.IsValid && (userHousehold.BudgetCategories.Select(bc => bc.Id).Contains(vm.BudgetCategoryId) || db.BudgetCategories.Find(vm.BudgetCategoryId).Name == "General") && userHousehold.Accounts.Select(a => a.Id).Contains(vm.AccountId)) { Transaction transaction = new Transaction(); transaction.Description = vm.Description; transaction.Amount = vm.Amount; transaction.AccountId = vm.AccountId; transaction.BudgetCategoryId = vm.BudgetCategoryId; transaction.Date = vm.Date; if (vm.Type == "+") { transaction.Expense = false; } else { transaction.Expense = true; } transaction.ForReconciled = false; Account account = db.Accounts.Find(transaction.AccountId); transaction.MadeById = User.Identity.GetUserId(); db.Transactions.Add(transaction); db.SaveChanges(); if (transaction.Expense) { account.CurrentBalance = account.CurrentBalance - transaction.Amount; } else { account.CurrentBalance = account.CurrentBalance + transaction.Amount; } db.Entry(account).Property("CurrentBalance").IsModified = true; db.SaveChanges(); account.ReconciledBalance = account.CurrentBalance; db.Entry(account).Property("ReconciledBalance").IsModified = true; db.SaveChanges(); return(RedirectToAction("Details", "Accounts", new { id = account.Id })); } if (vm.AccountId == 0 || !db.Accounts.ToList().Select(a => a.Id).Contains(vm.AccountId)) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } Account accountB = db.Accounts.Find(vm.AccountId); string currentUserId = User.Identity.GetUserId(); if (!accountB.Household.Members.Select(m => m.Id).Contains(currentUserId)) { return(RedirectToAction("Unauthorized", "Home")); } ViewBag.AccountName = accountB.Name; ViewBag.AccountId = vm.AccountId; ViewBag.BudgetCategoryId = new SelectList(db.BudgetCategories, "Id", "Name"); return(View()); }