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());
}
