public async Task Edit(TransactionEditViewModel model)
{
var transaction = Mapper.Map <Domains.DataObject.Transaction>(model);
_dbContext.Entry(transaction).State = EntityState.Modified;
await _dbContext.SaveChangesAsync();
}
// GET: Transactions/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Transaction transaction = db.Transactions.Find(id);
if (transaction == null)
{
return(HttpNotFound());
}
Account account = transaction.Account;
string currentUserId = User.Identity.GetUserId();
if (!account.Household.Members.Select(m => m.Id).Contains(currentUserId))
{
return(RedirectToAction("Unauthorized", "Home"));
}
ViewBag.AccountName = account.Name;
ViewBag.BudgetCategoryId = new SelectList(db.BudgetCategories, "Id", "Name", transaction.BudgetCategoryId);
TransactionEditViewModel vm = new TransactionEditViewModel();
vm.Id = transaction.Id;
vm.Description = transaction.Description;
vm.Amount = transaction.Amount;
vm.Expense = transaction.Expense;
vm.Date = transaction.Date;
vm.AccountId = transaction.AccountId;
vm.BudgetCategoryId = transaction.BudgetCategoryId;
vm.MadeById = transaction.MadeById;
return(View(vm));
}
// GET: Transaction/Edit/5
public async Task <ActionResult> Edit(Guid?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Transaction transaction = await db.Transactions.FindAsync(id);
if (transaction == null)
{
return(HttpNotFound());
}
TransactionEditViewModel vm = new TransactionEditViewModel
{
Id = transaction.Id,
Description = transaction.Description,
Amount = transaction.Amount,
Date = transaction.Date,
TransactionType = transaction.TransactionType,
BankAccount_Id = transaction.BankAccount.Id,
};
return(View(vm));
}
// GET: Transactions/Edit/5
public ActionResult Details(int id, int?budgetId)
{
var transaction = db.Transactions.Find(id);
var user = db.Users.Find(User.Identity.GetUserId());
var group = db.Groups.Find(user.GroupId);
var viewModel = new TransactionEditViewModel
{
Group = group,
User = user,
Transaction = transaction
};
if (budgetId == null)
{
viewModel.Budget = transaction.Budget;
}
else
{
viewModel.Budget = db.Budgets.Find(budgetId);
}
return(View(viewModel));
}
public void EditTransaction(TransactionEditViewModel model)
{
var transaction = Mapper.Map <Domains.DataObject.Transaction>(model);
_dbContext.Entry(transaction).State = EntityState.Modified;
var originalTransaction = _dbContext.GetOriginal(transaction);
// When Transaction Amount has changed
if (((originalTransaction.Income ? 1 : -1) * originalTransaction.Amount) != ((transaction.Income ? 1 : -1) * transaction.Amount))
{
// Set original Project's Actual value
if (originalTransaction.ProjectID.HasValue)
{
var originalProject = _dbContext.Projects.Find(originalTransaction.ProjectID.Value);
originalProject.ActualValue = originalProject.ActualValue + ((originalTransaction.Income ? -1 : 1) * originalTransaction.Amount);
_dbContext.Entry(originalProject).State = EntityState.Modified;
}
// and also set the actual Project's Actual value
if (transaction.ProjectID.HasValue)
{
var project = _dbContext.Projects.Find(transaction.ProjectID.Value);
project.ActualValue = project.ActualValue + ((transaction.Income ? 1 : -1) * transaction.Amount);
_dbContext.Entry(project).State = EntityState.Modified;
}
}
_dbContext.SaveChanges();
}
// Teste sendo ignorado pois não consegui fazer os Controllers funcionarem
public void Save_TransaçãoComValorMaiorQueLimiteCredito_RetornaErros()
{
//Arrange
transactionsController = new TransactionsController();
transactionTypeApiName = "credito";
var transactionEVM = new TransactionEditViewModel
{
Amount = "120,00",
CardBrandApiName = cardBrandApiName,
CardHolderName = "PEDRITA FLINTSTONE",
Cvv = "999",
ExpirationMonth = 01,
ExpirationYear = 2019,
Installments = 0,
Number = "5555666677778888",
Password = cardPassword,
TransactionTypeApiName = transactionTypeApiName
};
//Act
var transactionResult = transactionsController.Save(transactionEVM);
var test = new RedirectResult("test");
//Assert
Assert.IsNotNull(transactionResult);
Assert.AreSame(test, transactionResult);
}
public IActionResult Edit(int id, TransactionEditViewModel model)
{
var transaction = _transactionData.Get(id);
if (ModelState.IsValid)
{
transaction.Amount = model.Amount;
transaction.Date = model.Date;
transaction.Type = model.Type;
transaction.Category = _transactionData.GetCategoryBasedOnName(model.Category);
transaction.Wallet = _transactionData.GetWalletBasedOnName(model.Wallet);
if (transaction.Type == TransactionType.Invest)
{
transaction.Price = model.Price;
}
else
{
transaction.Price = null;
}
transaction.UserId = _currentUserId;
_transactionData.Commit();
return(RedirectToAction("Details", new { id = transaction.Id }));
}
return(View(transaction));
}
public ActionResult Edit([Bind(Include = "Id,Description,Amount,Expense,Date,AccountId,BudgetCategoryId,MadeById")] TransactionEditViewModel vm)
{
Transaction transaction = new Transaction();
if (ModelState.IsValid)
{
transaction.Id = vm.Id;
transaction.Description = vm.Description;
transaction.Amount = vm.Amount;
transaction.Expense = vm.Expense;
transaction.Date = vm.Date;
transaction.AccountId = vm.AccountId;
transaction.BudgetCategoryId = vm.BudgetCategoryId;
transaction.MadeById = vm.MadeById;
transaction.ForReconciled = false;
db.Entry(transaction).State = EntityState.Modified;
db.SaveChanges();
Transaction rTransaction = db.Transactions.FirstOrDefault(t => t.ReconciledTransactionId == transaction.Id);
if (rTransaction != null)
{
rTransaction.Description = transaction.Description;
rTransaction.BudgetCategoryId = transaction.BudgetCategoryId;
db.Entry(rTransaction).Property("Description").IsModified = true;
db.SaveChanges();
db.Entry(rTransaction).Property("BudgetCategoryId").IsModified = true;
db.SaveChanges();
}
return(RedirectToAction("Index", "Accounts"));
}
ViewBag.BudgetCategoryId = new SelectList(db.BudgetCategories, "Id", "Name", transaction.BudgetCategoryId);
return(View(transaction));
}
public virtual async Task <ActionResult> Edit(TransactionEditViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
model.CreatorID = await GetCurrentUserIdAsync();
_transactionService.EditTransaction(model);
return(RedirectToAction(MVC.Project.ActionNames.Index));
}
public PartialViewResult GetEditRow(int id)
{
var model = new TransactionEditViewModel();
model.Transaction = _db.Query(new GetTransactionByIdQuery(id));
// list all active ledgers AND the transactions current ledger (in case it's not active)
var ledgers = _db.Query(new GetAllLedgersQuery()).Where(l => l.IsActive || l.Ledger == model.Transaction.Ledger);
model.LedgerList = new SelectList(ledgers, "Ledger", "LedgerDesc", model.Transaction.Ledger);
model.AccountsList = new SelectList(_db.Query(new GetAllAccountsQuery()), "Id", "Desc", model.Transaction.Account);
return(PartialView(model));
}
public ServiceResult Update(TransactionEditViewModel model)
{
var oldEntity = _context.Transactions.FirstOrDefault(c => c.id_get.Equals(model.id_get));
var entity = AutoMapper.Mapper.Map(model, oldEntity);
_context.Update(entity);
var result = _context.SaveChanges();
if (result > 0)
{
return(ServiceResult.Okay());
}
return(ServiceResult.Error());
}
public async Task <ActionResult> Edit(TransactionEditViewModel vm)
{
if (ModelState.IsValid)
{
Transaction transaction = await db.Transactions.FindAsync(vm.Id);
transaction.Description = vm.Description;
db.Entry(transaction).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index", new { acctId = transaction.BankAccount.Id }));
}
return(View(vm));
}
public Model.Transaction GetTransaction(TransactionEditViewModel viewModel, Model.BankAccount bankAccount)
{
var transaction = new Model.Transaction()
{
Id = viewModel.Id,
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 TransactionEditViewModel(_storages, null);
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);
}
// Ação de Nova Transação com página consumindo API
public ActionResult NewApi()
{
//Pega todos os Transactiontypes(tipos de transações)
var transactionType = _unitOfWork.TransactionTypes.GetAll();
//Pega todos os CardBrands(bandeiras de cartões)
var cardBrand = _unitOfWork.CardBrands.GetAll();
//Cria nova instância vazia de TransactionEditViewModel com as listas de TransactionTypes e CardBrands
var viewModel = new TransactionEditViewModel
{
TransactionTypes = transactionType,
CardBrands = cardBrand
};
//Retorna a TransactionViewModel para a view TransactionForm(nova transação)
return(View("TransactionApiForm", viewModel));
}
public TransactionEditViewModel GetViewModel(Model.Transaction transaction, CurrencyLogic currencyLogic)
{
var viewModel = new TransactionEditViewModel()
{
Id = transaction.Id,
Name = transaction.Name,
Balance = transaction.Amount,
AccountBalance = transaction.AccountBalance,
SetDate = transaction.SetDate,
Description = transaction.Description,
Currency = currencyLogic.GetCurrencyIconById(transaction.BankAccount.Currency),
BankAccountId = transaction.BankAccount.Id,
UserId = transaction.BankAccount.User.Id
};
return(viewModel);
}
public void ConstructorWithTransactionTest()
{
var viewModel = new TransactionEditViewModel(_storages, _transaction);
Assert.IsNotNull(viewModel.ChildrenTransactions);
Assert.AreEqual(22m, viewModel.Total);
Assert.AreEqual(0.451m, viewModel.Weight);
Assert.IsFalse(viewModel.IsComplexTransaction);
Assert.IsTrue(viewModel.IsExistingTransaction);
Assert.IsNotNull(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);
}
public IActionResult Create(TransactionEditViewModel model)
{
if (ModelState.IsValid)
{
var newTransaction = new Transaction();
newTransaction.Amount = model.Amount;
newTransaction.Date = model.Date;
newTransaction.Type = model.Type;
newTransaction.UserId = _currentUserId;
newTransaction.Wallet = _transactionData.GetWalletBasedOnName(model.Wallet);
newTransaction.Category = _transactionData.GetCategoryBasedOnName(model.Category);
newTransaction = _transactionData.Add(newTransaction);
_transactionData.Commit();
return(RedirectToAction("Details", new { id = newTransaction.Id }));
}
return(View());
}
public ActionResult Edit(TransactionEditViewModel viewModel)
{
var status = false;
if (ModelState.IsValid && User.Identity.GetUserId() == viewModel.UserId && Request.IsAjaxRequest() &&
_readTransaction.IsTransactionCorrect(viewModel.Id, viewModel.BankAccountId, viewModel.UserId))
{
var binder = new FromTransactionEditViewModel();
var bankAccount = _readBankAccount.GetBankAccountById(viewModel.BankAccountId);
var model = binder.GetTransaction(viewModel, bankAccount);
_writeTransaction.Edit(model);
status = true;
return(new JsonResult()
{
Data = new { status = status }
});
}
return(new JsonResult()
{
Data = new { status = status }
});
}
public ActionResult Save(TransactionEditViewModel transEditView)
{
//Coloca valor do parâmetro show_errors numa var booleana para uso futuro
var showErros = true;
//Cria lista de erros encontrados durante a validação
List <Error> errors = new List <Error>();
TransactionApiInputDto inputTransaction;
var transactionType = new TransactionType();
var cardBrand = new CardBrand();
var card = new Card();
var clientInDB = new Client();
decimal transAmountInDecimal = 0m;
//A transação é presumida recusada inicialmente
var statusCode = Constantes.scRecusada;
var statusReason = Constantes.srErroInesperado;
//Pega todos os Transactiontypes(tipos de transações)
var transactionTypes = _unitOfWork.TransactionTypes.GetAll();
//Pega todos os CardBrands(bandeiras de cartões)
var cardBrands = _unitOfWork.CardBrands.GetAll();
//Atribuindo os TransactionTypes e os CardBrands a viewmodel caso tenhamos que voltar para a view
transEditView.TransactionTypes = transactionTypes;
transEditView.CardBrands = cardBrands;
//Se algum erro foi gerado até aqui...
if (!ModelState.IsValid)
{
//Retorna a TransactionEditViewModel para a view TransactionForm(nova transação)
return(View("TransactionForm", transEditView));
}
//Esse teste é executado somente aqui e antes de chamar o validador (não é executado no validador)
var tempAmount = transEditView.Amount.Replace(",", "");
var amountIsDigit = tempAmount.All(char.IsDigit);
//Verifica se todos os caracteres do campo card_number são números
if (!amountIsDigit)
{
ModelState.AddModelError("", "410 - O valor informado não é válido.");
}
if (!ModelState.IsValid)
{
//Retorna a TransactionEditViewModel para a view TransactionForm(nova transação)
return(View("TransactionForm", transEditView));
}
var dblAmount = Convert.ToDouble(transEditView.Amount);
var intAmount = Convert.ToInt32(dblAmount * 100);
//Move os dados da Edit View para a Dto.
inputTransaction = new TransactionApiInputDto
{
amount = intAmount,
card_brand = transEditView.CardBrandApiName,
card_holder_name = transEditView.CardHolderName,
card_number = transEditView.Number,
cvv = transEditView.Cvv,
expiration_month = transEditView.ExpirationMonth,
expiration_year = transEditView.ExpirationYear,
installments = transEditView.Installments,
password = transEditView.Password,
show_errors = showErros,
transaction_type = transEditView.TransactionTypeApiName,
};
var validador = new Validador(_unitOfWork, showErros);
validador.ProcessTransaction(inputTransaction);
statusCode = validador.statusCode;
statusReason = validador.statusReason;
transAmountInDecimal = validador.transAmountInDecimal;
transactionType = validador.transactionType;
cardBrand = validador.cardBrand;
card = validador.card;
clientInDB = validador.clientInDB;
errors = validador.errors;
// *** FIM DAS VALIDAÇÕES ***
//Adiciona todos os error do validador ao ModelState
if (errors.Count > 0)
{
foreach (var e in errors)
{
ModelState.AddModelError("", e.error_code + " - " + e.error_message);
}
}
if (!ModelState.IsValid)
{
//Retorna a TransactionEditViewModel para a view TransactionForm(nova transação)
return(View("TransactionForm", transEditView));
}
// Validação Terminada com Sucesso \__________________
var cardNumberFirst = "";
var cardNumberLast = "";
if (!String.IsNullOrEmpty(transEditView.Number))
{
cardNumberFirst = transEditView.Number.Substring(1, 4);
if (transEditView.Number.Length >= 4)
{
cardNumberLast = transEditView.Number.Substring(transEditView.Number.Length - 4, 4);
}
}
//Gera registro da transação(transaction log) solicitada para ser salva na base de dados
var transactionLog = new TransactionLog
{
Amount = Convert.ToInt32(transAmountInDecimal * 100),
Card_brand = card.CardBrand.ApiName,
Card_holder_name = transEditView.CardHolderName,
Card_number_first = cardNumberFirst,
Card_number_last = cardNumberLast,
Installments = transEditView.Installments,
Transaction_type = transEditView.TransactionTypeApiName,
Status_code = statusCode,
Status_reason = statusReason,
Creation_timestamp = DateTime.Now,
//Errors = null
};
//Adiciona registro no log de transações ao banco de dados
_unitOfWork.TransactionLogs.Add(transactionLog);
if (errors.Count > 0)
{
foreach (var e in errors)
{
var errorLog = new ErrorLog
{
TransactionLogId = transactionLog.Id,
Error_code = e.error_code,
Error_message = e.error_message
};
_unitOfWork.ErrorLogs.Add(errorLog);
}
}
;
//Criar a transação vinculada ao cartão e coloca a data de criação
var transaction = new Transaction {
Amount = transAmountInDecimal,
CardId = card.Id,
CreationTimestamp = DateTime.Now,
Installments = transEditView.Installments,
TransactionTypeId = transactionType.Id,
TransactionLogId = transactionLog.Id
};
//Adiciona a transação ao banco de dados
_unitOfWork.Transactions.Add(transaction);
//Atualiza o saldo do cliente com o valor da transação.
clientInDB.Saldo = clientInDB.Saldo - transaction.Amount;
_unitOfWork.Complete();
//Retorna a TransactionEditViewModel para a view Index(listagem de transações)
return(RedirectToAction("Index", new { cardId = transaction.CardId }));
}
public async Task PutTransaction(TransactionEditViewModel model)
{
await _apiTransactionService.Edit(model);
}
public void TestTransactionEditViewModelOK()
{
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 transactionEntity = new Entities.Transaction
{
CreditAccount = incomeAccountEntity,
DebitAccount = checkingAccountEntity,
Amount = 10m,
At = new DateTime(2018, 1, 1, 9, 0, 0)
};
sqliteMemoryWrapper.DbContext.Transactions.Add(transactionEntity);
sqliteMemoryWrapper.DbContext.SaveChanges();
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 viewModel = new TransactionEditViewModel(
loggerFactory,
accountService,
transactionService,
mockViewModelFactory.Object,
transactionEntity.TransactionId
);
viewModel.Amount = 20m;
viewModel.At = new DateTime(2018, 1, 1, 9, 25, 0);
viewModel.OKCommand.Execute(this);
List <Transaction> transactions = transactionService.GetAll().ToList();
Assert.AreEqual(1, transactions.Count);
Assert.AreEqual(transactionEntity.CreditAccount.AccountId, transactions[0].CreditAccount.AccountId);
Assert.AreEqual(transactionEntity.DebitAccount.AccountId, transactions[0].DebitAccount.AccountId);
Assert.AreEqual(viewModel.Amount, transactions[0].Amount);
Assert.AreEqual(viewModel.At, transactions[0].At);
}
}