public IActionResult Transfer(TransferVM model)
{
var repo = BankRepository.Instance();
if (ModelState.IsValid)
{
try
{
var fromAccount = repo.GetAccount(model.fromAccountNumber);
var recievingAccount = repo.GetAccount(model.recievingAccountNumber);
repo.Transfer(fromAccount, recievingAccount, model.Amount);
var transferVM = new TransferVM();
transferVM.FromAccount = AccountVM.Create(fromAccount);
transferVM.RecievingAccount = AccountVM.Create(recievingAccount);
return(View("TransferSuccess", transferVM));
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.Message);
}
}
return(View("Index", model));
}
public void VerifyTransferSource()
{
var testAccount = new Account(7, new Customer(), 1000);
BankRepository.AddAccount(testAccount);
var testAccount2 = new Account(8, new Customer(), 1000);
BankRepository.AddAccount(testAccount2);
var transfer = new TransferVM
{
FromAccountNumber = 7,
ToAccountNumber = 8,
Amount = 1000
};
Bank.Transfer(transfer);
var expected = 0;
var actual = BankRepository.GetAccount(7).Balance;
Assert.Equal(expected, actual);
}
// GET: Transactions/CreateTransfer
public ActionResult CreateTransfer()
{
ViewBag.FromBankAccountId = new SelectList(db.BankAccounts, "Id", "AccountName");
ViewBag.ToBankAccountId = new SelectList(db.BankAccounts, "Id", "AccountName");
var model = new TransferVM();
model.TransactionType = TransactionType.Transfer;
return(View(model));
}
public async Task <IActionResult> Transfer(TransferVM model)
{
var transferDto = new TransferDTO
{
FromAccount = model.FromAccount,
ToAccount = model.ToAccount,
TransferAmount = model.TransferAmount
};
await _transferService.Transfer(transferDto);
return(View("Index"));
}
private void OnClickTransfer(object sender, EventArgs args)
{
Analytics.TrackEvent("Wallet | Account | Transfer");
var task = new TransferVM(VM.Parent)
{
SelectedSource = VM.Account
};
Navigation.PushAsync(new TransferPage {
BindingContext = task
});
}
public ActionResult CreateTransfer(TransferVM model)
{
if (ModelState.IsValid)
{
var wdTransaction = new Transaction()
{
AccountId = model.FromBankAccountId,
BudgetItemId = null,
OwnerId = User.Identity.GetUserId(),
TransactionType = model.TransactionType,
Created = DateTime.Now,
Amount = model.Amount,
Memo = model.Memo,
IsDeleted = false
};
var depTransaction = new Transaction()
{
AccountId = model.ToBankAccountId,
BudgetItemId = null,
OwnerId = User.Identity.GetUserId(),
TransactionType = model.TransactionType,
Created = DateTime.Now,
Amount = model.Amount,
Memo = model.Memo,
IsDeleted = false
};
db.Transactions.Add(wdTransaction);
db.Transactions.Add(depTransaction);
db.SaveChanges();
var thisWdTransaction = db.Transactions.Include(t => t.BudgetItem).FirstOrDefault(t => t.Id == wdTransaction.Id);
var thisDepTransaction = db.Transactions.Include(t => t.BudgetItem).FirstOrDefault(t => t.Id == depTransaction.Id);
thisWdTransaction.TransferFunds(thisDepTransaction);
return(RedirectToAction("Dashboard", "Home"));
}
ViewBag.ErrorMessage = "Something went wrong. Please try again.";
ViewBag.FromBankAccountId = new SelectList(db.BankAccounts, "Id", "AccountName");
ViewBag.ToBankAccountId = new SelectList(db.BankAccounts, "Id", "AccountName");
var tryAgain = new TransferVM();
tryAgain.TransactionType = TransactionType.Withdrawal;
return(View(tryAgain));
}
public IActionResult Transfer([FromBody] TransferVM transferVM)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userId = new Guid(Thread.CurrentPrincipal?.Identity?.Name);
var result = _transferService.Transfer(userId, transferVM.AccountNumberOrigin, transferVM.AccountNumberDestination, transferVM.Value);
return(Ok(new Result()
{
Value = result,
SuccessMessage = "Transferência efetuada com sucesso."
}));
}
public void VerifyTransfer()
{
CreateCustommer();
var transfer = new TransferVM
{
FromAccountNumber = 1002,
ToAccountNumber = 1003,
Ammount = 1000
};
BankRepository.TransferFunds(transfer);
decimal expected = 2000;
decimal actual = BankRepository.Customers.FirstOrDefault(x => x.CustomerId == 1002).Accounts.FirstOrDefault().Balance;
Assert.Equal(expected, actual);
}
public static string TransferFunds(TransferVM transfer)
{
var fromAccount = FindAccount(transfer.FromAccountNumber);
var toAccount = FindAccount(transfer.ToAccountNumber);
if (fromAccount != null && toAccount != null)
{
if (transfer.Ammount <= fromAccount.Balance)
{
fromAccount.Balance -= transfer.Ammount;
toAccount.Balance += transfer.Ammount;
return($"{transfer.Ammount}.kr överfört från konto {fromAccount.AccountNumber} till konto {toAccount.AccountNumber}. Aktuella Saldon är: {fromAccount.AccountNumber} : {fromAccount.Balance}.kr & {toAccount.AccountNumber} : {toAccount.Balance}.kr");
}
return("Ej tillräckligt på kontot.");
}
return("Något av kontona kunde inte hittas.");
}
public static bool Transfer(TransferVM transfer)
{
if (AccountExists(transfer.FromAccountNumber) && AccountExists(transfer.ToAccountNumber))
{
var accountFrom = BankRepository.GetAccount(transfer.FromAccountNumber);
var accountTo = BankRepository.GetAccount(transfer.ToAccountNumber);
if (accountFrom.Balance >= transfer.Amount)
{
accountFrom.Withraw(transfer.Amount);
accountTo.Deposit(transfer.Amount);
return(true);
}
}
return(false);
}
public async Task <IActionResult> Post([FromBody] TransferVM transfer)
{
try
{
await transferSvc.Exec(
fromAccountAgency : transfer.FromAgency,
fromAccountNumber : transfer.FromNumber,
toAccountAgency : transfer.ToAgency,
toAccountNumber : transfer.ToNumber,
value : transfer.TransacionValue);
return(Ok());
}
catch (Exception error)
{
return(BadRequest(new ErrorMessage(error.Message)));
}
}
public PartialViewResult Transfer(TransferVM vm)
{
string result;
var accounts = new List <Account>();
result = _bankRepository.Transfer(vm.FromAccount, vm.ToAccount, vm.Amount);
if (result == "success")
{
accounts.Add(_bankRepository.Accounts.FirstOrDefault(c => c.Key == vm.FromAccount).Value);
accounts.Add(_bankRepository.Accounts.FirstOrDefault(c => c.Key == vm.ToAccount).Value);
return(PartialView("_TransferStatus", accounts));
}
else
{
return(PartialView("_ErrorMessage", _errorMessagesDict[result]));
}
}
public IActionResult Transfer(TransferVM transfer)
{
if (Bank.AccountExists(transfer.FromAccountNumber) && Bank.AccountExists(transfer.ToAccountNumber))
{
if (Bank.SufficientFunds(transfer.FromAccountNumber, transfer.Amount))
{
Bank.Transfer(transfer);
return(RedirectToAction("Index", "Home"));
}
else
{
ModelState.AddModelError(string.Empty, "Error! Insufficient funds.");
return(View());
}
}
ModelState.AddModelError(string.Empty, "Error! We couldn't find the account.");
return(View());
}
public async Task <IActionResult> Transfer(int id, [Bind("AccountIDFrom, AccountIDTo, Amount, AccountFromBalance")] TransferVM transferVM)
{
var accounts = (await _repo.Get(UserManager.GetUserId(User)))
.Where(b => !b.IsClosed)
.Except(new List <Account> {
await _repo.Get(transferVM.AccountIDFrom)
});
List <Account> validAccounts = new List <Account>();
foreach (var item in accounts)
{
validAccounts.Add(item);
}
if (ModelState.IsValid)
{
try
{
await _repo.Transfer(await _repo.Get(transferVM.AccountIDFrom), await _repo.Get(transferVM.AccountIDTo), transferVM.Amount);
}
catch
{
if (!AccountExists(transferVM.AccountIDFrom))
{
return(NotFound());
}
else if (!AccountExists(transferVM.AccountIDTo))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
transferVM.Accounts = validAccounts;
transferVM.AccountIDFrom = (int)id;
return(View(transferVM));
}
public IActionResult TransferBalance(TransferVM transfer)
{
var checkwallet = walletService.GetWallets().Where(s => s.Address == transfer.RecieverWallet).FirstOrDefault();
if (checkwallet != null)
{
var senderwalletAddress = transfer.SenderWallet;
var recieverwalletAddress = transfer.RecieverWallet;
var senderID = userManager.GetUserAsync(HttpContext.User).Result.Id;
var rcvrID = walletService.GetWallets().Where(s => s.Address == recieverwalletAddress).FirstOrDefault().UserID;
var swlt = walletService.GetWallets().Where(s => s.Address == senderwalletAddress).FirstOrDefault();
var rwlt = walletService.GetWallets().Where(s => s.Address == recieverwalletAddress).FirstOrDefault();
swlt.Balance = swlt.Balance - transfer.Amount;
walletService.UpdateWallet(swlt);
rwlt.Balance = rwlt.Balance + transfer.Amount;
walletService.UpdateWallet(rwlt);
Transfer trs = new Transfer();
trs.AddDate = DateTime.Now;
trs.Amount = transfer.Amount;
trs.SenderID = senderID;
trs.RecieverID = rcvrID;
trs.SenderWalletAddress = senderwalletAddress;
trs.RecieverWalletAddress = recieverwalletAddress;
trs.Status = 1;
transferService.InsertTransfer(trs);
return(Ok(new TransactionResponse {
Message = "Successfully send to" + recieverwalletAddress + "", IsSuccess = true
}));
}
else
{
return(Ok(new TransactionResponse {
Message = "Transfer failed", IsSuccess = false
}));
}
}
public void TransferInsufficiantFunds()
{
var testAccount = new Account(11, new Customer(), 1000);
BankRepository.AddAccount(testAccount);
var testAccount2 = new Account(12, new Customer(), 1000);
BankRepository.AddAccount(testAccount2);
var transfer = new TransferVM
{
FromAccountNumber = 11,
ToAccountNumber = 12,
Amount = 1001
};
Bank.Transfer(transfer);
var expected = 1000;
var actual = BankRepository.GetAccount(11).Balance;
Assert.Equal(expected, actual);
}
public void VerifyTransferDestination()
{
var testAccount = new Account(9, new Customer(), 1000);
BankRepository.AddAccount(testAccount);
var testAccount2 = new Account(10, new Customer(), 1000);
BankRepository.AddAccount(testAccount2);
var transfer = new TransferVM
{
FromAccountNumber = 9,
ToAccountNumber = 10,
Amount = 1000
};
Bank.Transfer(transfer);
var expected = 2000;
var actual = BankRepository.GetAccount(10).Balance;
Assert.Equal(expected, actual);
}
public IActionResult Transfer(TransferVM obj)
{
ViewBag.Message = BankRepository.TransferFunds(obj);
return(View());
}
public SelectOwnDestinationPage(TransferVM vm)
{
BindingContext = VM = vm;
InitializeComponent();
}
