public ActionResult Withdraw(WithdrawViewModel withdrawViewModel)
{
if (ModelState.IsValid)
{
if (CardsService.HasEnoughMoney(User.CardId, Convert.ToDecimal(withdrawViewModel.Amount)))
{
if (OperationsService.WithdrawMoney(User.CardId, Convert.ToDecimal(withdrawViewModel.Amount)))
{
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError("", "Could not withdraw money. Try again");
}
}
else
{
ModelState.AddModelError("", "Not enough money on the card balance");
}
}
var currentCardBalance = CardsService.GetBalance(User.CardId);
ViewData["currentCardBalance"] = currentCardBalance;
return(View());
}
public ActionResult Withdraw(WithdrawViewModel vm)
{
try
{
if (ModelState.IsValid)
{
var db = ApplicationDbContext.Create();
var currentUserId = User.Identity.GetUserId();
var checkingAccount = db.CheckingAccounts.Where(ac => ac.ApplicationUserId == currentUserId && ac.AccountNumber == vm.AccountNumber).FirstOrDefault();
if (checkingAccount == null)
{
throw new Exception("Invalid Account!!");
}
if (checkingAccount.Balance < vm.Amount)
{
throw new Exception("Not enough balance!!");
}
db.Transactions.Add(new Transaction {
Amount = -(vm.Amount), TimeStamp = DateTime.Now, CheckingAccountId = checkingAccount.ID
});
checkingAccount.Balance -= vm.Amount;
db.SaveChanges();
//return RedirectToAction("Index");
return(RedirectToAction("Index", "Banking"));
}
return(View());
}
catch (Exception ex)
{
ViewBag.ErrorMessage = ex.ToString();
return(View());
}
}
public IActionResult Withdraw(WithdrawViewModel viewModel, int id, decimal amount)
{
var balanceCheck = _dbContext.Accounts.FirstOrDefault(r => r.AccountId == id);
if (ModelState.IsValid && amount > 0 && amount < balanceCheck.Balance)
{
var dbTransaction = new Transactions();
_dbContext.Transactions.Add(dbTransaction);
var account = _dbContext.Accounts.FirstOrDefault(r => r.AccountId == id);
var currentBalance = account.Balance;
dbTransaction.AccountId = id;
dbTransaction.Amount = amount - (amount * 2);
dbTransaction.Date = DateTime.Now;
dbTransaction.Balance = currentBalance - amount;
dbTransaction.Operation = "Withdraw";
dbTransaction.Type = "Debit";
account.Balance = currentBalance - amount;
_dbContext.SaveChanges();
return(RedirectToAction("AccountIndex", "Account"));
}
var accounts = _dbContext.Accounts.FirstOrDefault(r => r.AccountId == id);
viewModel.Balance = accounts.Balance;
ModelState.AddModelError("Error", "Invalid amount");
return(View(viewModel));
}
public async Task <IActionResult> Withdraw(WithdrawViewModel model)
{
if (!ModelState.IsValid)
{
this.StatusMessage = "Error! The withdraw is not completed.";
return(PartialView("_StatusMessage", this.StatusMessage));
}
var user = await this.userManager.GetUserAsync(HttpContext.User);
var userBalance = await this.userBalanceService.GetUserBalanceByIdAsync(user.Id);
if (userBalance < model.Amount)
{
this.StatusMessage = "Error! The withdraw is not completed.";
return(PartialView("_StatusMessage", this.StatusMessage));
}
await this.userBalanceService.ReduceMoneyAsync(model.Amount, user.Id);
var card = await this.cardService.GetCardNumberByIdAsync(model.BankCardId);
var userCurrency = await this.currencyService.GetUserCurrencyAsync(user.Id);
await this.transactionService.AddTransactionAsync(TransactionType.Withdraw,
user.Id, card.Number, model.Amount, userCurrency);
string currencySymbol = WebConstants.CurrencySymbols[user.Currency];
this.StatusMessage = $"Successfully withdrawn {model.Amount} {currencySymbol}.";
return(PartialView("_StatusMessage", this.StatusMessage));
}
public async Task <IActionResult> Withdraw([FromBody] WithdrawViewModel withdrawViewModel)
{
try
{
if (!ModelState.IsValid)
{
ModelState.AddModelError("WithdrawViewModelInvalid", "Informe um modelo válido");
return(BadRequest(ModelState));
}
var account = await _accountAppService.GetByAccountNumberAndAgencyAsync(withdrawViewModel.AccountNumber, withdrawViewModel.Agency);
if (account == null)
{
return(NotFound("Conta não encontrada"));
}
await _accountAppService.WithDraw(account, withdrawViewModel.Value);
var result = _mapper.Map <AccountListViewModel>(account);
return(Ok(result));
}
catch (ArgumentException ex)
{
return(BadRequest(ex.Message));
}
catch (Exception ex)
{
return(BadRequest($"Erro ao realizar saque. {ex.Message}"));
}
}
public async Task <IActionResult> Withdraw(WithdrawViewModel model)
{
TransactionStatusViewModel transactionStatus = new TransactionStatusViewModel();
try
{
var response = await _transactionProvider.Withdraw(model);
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
var jsoncontent = await response.Content.ReadAsStringAsync();
transactionStatus = JsonConvert.DeserializeObject <TransactionStatusViewModel>(jsoncontent);
return(View("TransactionStatus", transactionStatus));
}
else if (response.StatusCode == System.Net.HttpStatusCode.NotFound)
{
ModelState.AddModelError("", "Having server issue while adding record");
return(View(model));
}
else if (response.StatusCode == System.Net.HttpStatusCode.InternalServerError)
{
ViewBag.Message = "Internal Server Error! Please try again later";
return(View(model));
}
}
catch (Exception ex)
{
_logger.Error("Exceptions occured due to " + ex.Message);
}
ModelState.AddModelError("", "Having some unexpected error while processing transaction");
return(View(model));
}
public IActionResult Withdraw(WithdrawViewModel model)
{
if (ModelState.IsValid)
{
var command = new WithdrawCommand
{
AccountId = model.AccountId,
Amount = model.Amount,
};
var query = new WithdrawHandler(new BankContext()).Handler(command);
if (query.IsCompletedSuccessfully)
{
TempData["Success"] = $"{model.Amount.ToString("C")} withdrawn from account";
return(View());
}
else
{
TempData["Error"] = $"Withdraw failed";
return(View());
}
}
return(View());
}
public async Task ReturnsViewResult_WhenCalled()
{
// Arrange
var cardServiceMock = new Mock <ICardService>();
var userBalServiceMock = new Mock <IUserBalanceService>();
var transactionServiceMock = new Mock <ITransactionService>();
var currencyServiceMock = new Mock <ICurrencyService>();
var userManagerMock = SetupUserManagerMock();
var controller = SetupController(cardServiceMock, userBalServiceMock, transactionServiceMock, userManagerMock, currencyServiceMock);
var model = new WithdrawViewModel()
{
Currency = Currency.BGN
};
var user = controller.User;
var appUser = new User()
{
UserName = "******"
};
userManagerMock
.Setup(u => u.GetUserAsync(user))
.ReturnsAsync(appUser);
// Act
var result = await controller.Index();
// Assert
Assert.IsInstanceOfType(result, typeof(ViewResult));
}
private TransactionResponseModel Withdraw(WithdrawViewModel model, IUnitOfWork unit)
{
var failureResponse = new TransactionResponseModel
{
IsSuccessful = false
};
var account = unit.Repository <Account>().Get().FirstOrDefault(a => a.AccountNumber == model.AccountNumber);
if (account != null)
{
if (account.Balance >= model.Amount)
{
account.Balance -= model.Amount;
var entity = unit.Repository <Account>().Attach(account);
return(new TransactionResponseModel
{
IsSuccessful = true,
CurrentBalance = entity.Balance,
Message = Message.SuccessfulTracsaction
});
}
failureResponse.Message = Message.BalanceIsNotEnough;
return(failureResponse);
}
failureResponse.Message = Message.AccountIsInvalid;
return(failureResponse);
}
public async Task Withdraw_Given_InvalidAccount_Then_ReturnNotFound()
{
// Arrange
var mockService = new Mock <IAccountAppService>();
var invalidWithdrawViewModel = new WithdrawViewModel()
{
AccountNumber = 0,
Agency = 0
};
var sourceAccount = invalidWithdrawViewModel.AccountNumber;
mockService.Setup(service => service.GetByAccountNumberAndAgencyAsync(
invalidWithdrawViewModel.AccountNumber,
invalidWithdrawViewModel.Agency
)).ReturnsAsync((Account)null);
var controller = new AccountController(mockService.Object);
// Act
var result = await controller.Withdraw(invalidWithdrawViewModel);
//Assert
Assert.IsType <NotFoundObjectResult>(result);
}
public async Task <IActionResult> Create
([Bind("WithdrawId,WithdrawDate,Amount,AtmId,UserId")] WithdrawViewModel withdraw)
{
if (ModelState.IsValid)
{
var model = withdraw.ToModel(_context);
bool hasError = model.AutomatedTellerMachine == null || model.User == null;
try
{
model.CurrencyDictionary = WithdrawHelper.WithdrawFromAtm(model.User, model.AutomatedTellerMachine, withdraw.Amount, _context);
}
catch (InsufficentFundsException)
{
ModelState.AddModelError("UserId", $"User {model.User.Name} has insufficient funds (${model.User.Balance}) to withdraw ${withdraw.Amount}");
hasError = true;
}
catch (InsufficientChangeException)
{
ModelState.AddModelError("AtmId", $"ATM {model.AutomatedTellerMachine.Alias} has insufficient change to withdraw ${withdraw.Amount}");
hasError = true;
}
catch
{
throw;
}
if (model.AutomatedTellerMachine == null)
{
ModelState.AddModelError("AtmId", "ATM not found");
}
if (model.User == null)
{
ModelState.AddModelError("UserId", "User not found");
}
if (hasError)
{
ViewBag.Users = await GetUsers();
ViewBag.Atms = await GetAtms();
return(View(withdraw));
}
model.WithdrawDate = DateTime.Now;
_context.Add(model);
await _context.SaveChangesAsync();
(TempData["SuccessMessage"], TempData["InfoMessages"]) = BuildWithdrawMessage(model);
return(RedirectToAction("Index"));
}
return(View(withdraw));
}
public TransactionResponseModel Withdraw(WithdrawViewModel model)
{
using (var unit = _unitOfWorkFactory.Create())
{
var result = Withdraw(model, unit);
unit.Save();
return(result);
}
}
//[HttpPost]
public ActionResult Withdraw(WithdrawViewModel wvm)
{
using (FinancialOperations fo = new FinancialOperations())
{
fo.WithDraw(wvm.Value, wvm.Date, wvm.Origin, wvm.SelectedFundId, wvm.SelectedReserveId, User.Identity.Name);
}
return(SavingsAccountPartial());
}
public IActionResult Withdraw([FromRoute] int id)
{
var viewModel = new WithdrawViewModel();
var accounts = _dbContext.Accounts.FirstOrDefault(r => r.AccountId == id);
viewModel.Balance = accounts.Balance;
return(View(viewModel));
}
public async Task InvokeCorrectServiceMethod_WhenCalled()
{
// Arrange
var cardServiceMock = new Mock <ICardService>();
var userBalServiceMock = new Mock <IUserBalanceService>();
var transactionServiceMock = new Mock <ITransactionService>();
var currencyServiceMock = new Mock <ICurrencyService>();
var userManagerMock = SetupUserManagerMock();
var controller = SetupController(cardServiceMock, userBalServiceMock, transactionServiceMock, userManagerMock, currencyServiceMock);
var model = new WithdrawViewModel()
{
Currency = Currency.BGN,
Amount = 1
};
var user = controller.User;
var appUser = new User()
{
Id = "guid",
Currency = Currency.BGN
};
userManagerMock
.Setup(u => u.GetUserAsync(user))
.ReturnsAsync(appUser);
var userBalance = 2m;
userBalServiceMock
.Setup(ub => ub.GetUserBalanceByIdAsync(It.IsAny <string>()))
.ReturnsAsync(userBalance);
var card = new CardNumberDto()
{
Id = 1,
Number = "1234"
};
cardServiceMock
.Setup(c => c.GetCardNumberByIdAsync(It.IsAny <int>()))
.ReturnsAsync(card);
currencyServiceMock
.Setup(c => c.GetUserCurrencyAsync(It.IsAny <string>()))
.ReturnsAsync(Currency.BGN);
// Act
var result = await controller.Withdraw(model);
// Assert
userBalServiceMock
.Verify(ub => ub.ReduceMoneyAsync(It.IsAny <decimal>(),
It.IsAny <string>()), Times.Once);
}
public async Task <TransactionResponseModel> WithdrawAsync(WithdrawViewModel model)
{
using (var unit = _unitOfWorkFactory.Create())
{
var result = await WithdrawAsync(model, unit);
var saveResult = unit.SaveAsync().Result;
return(HandleSaving(saveResult, result, unit, model.AccountNumber));
}
}
public ActionResult SelectAmount(string accountNumber)
{
var ser = new TransactionService();
var model = new WithdrawViewModel()
{
Balance = ser.GetBalance(accountNumber),
Account = accountNumber
};
return(View(model));
}
public ActionResult HomeOption(Account account)
{
var wvm = new WithdrawViewModel();
wvm.Id = account.AccountId;
wvm.CurrentBalance = account.Balance;
wvm.WithdrawAmount = 0;
wvm.Transactions = _context.Traansactions.Where(m => m.AccountId == wvm.Id).ToList();
return(View(wvm));
//return RedirectToAction("ShowVerifiedView", "Eatm", new RouteValueDictionary(wvm));
}
public async Task <IActionResult> Withdraw()
{
var customer = await CMgr.GetCustomerAsync(CustomerID);
var viewModel = new WithdrawViewModel
{
Customer = customer
};
return(View(viewModel));
}
public async Task <IActionResult> Withdraw(int id, WithdrawViewModel model)
{
string msg = null;
if (ModelState.IsValid)
{
msg = await new WithdrawCommand().RunAsync(_context, model.Withdraw);
}
model.Message = msg;
return(View(model));
}
public async Task <IActionResult> Index()
{
var user = await this.userManager.GetUserAsync(HttpContext.User);
var model = new WithdrawViewModel()
{
Currency = user.Currency
};
return(View(model));
}
public async Task ReturnsPartialViewResult_WhenValidModelPassed()
{
// Arrange
var cardServiceMock = new Mock <ICardService>();
var userBalServiceMock = new Mock <IUserBalanceService>();
var transactionServiceMock = new Mock <ITransactionService>();
var currencyServiceMock = new Mock <ICurrencyService>();
var userManagerMock = SetupUserManagerMock();
var controller = SetupController(cardServiceMock, userBalServiceMock, transactionServiceMock, userManagerMock, currencyServiceMock);
var model = new WithdrawViewModel()
{
Currency = Currency.BGN,
Amount = 1
};
var user = controller.User;
var appUser = new User()
{
Id = "guid",
Currency = Currency.BGN
};
userManagerMock
.Setup(u => u.GetUserAsync(user))
.ReturnsAsync(appUser);
var userBalance = 2m;
userBalServiceMock
.Setup(ub => ub.GetUserBalanceByIdAsync(It.IsAny <string>()))
.ReturnsAsync(userBalance);
var card = new CardNumberDto()
{
Id = 1,
Number = "1234"
};
cardServiceMock
.Setup(c => c.GetCardNumberByIdAsync(It.IsAny <int>()))
.ReturnsAsync(card);
currencyServiceMock
.Setup(c => c.GetUserCurrencyAsync(It.IsAny <string>()))
.ReturnsAsync(Currency.BGN);
// Act
var result = await controller.Withdraw(model);
// Assert
Assert.IsInstanceOfType(result, typeof(PartialViewResult));
}
public ActionResult Refund([Bind(Prefix = "withdrawModel")] WithdrawViewModel model, int?chipsId)
{
ResponseModel response = new ResponseModel();
//model.Amount = 230;
ModelState.Remove("withdrawModel.Amount");
if (chipsId == null)
{
response.Success = false;
response.Msg = "您提交的信息有误！";
return(Json(response, JsonRequestBehavior.AllowGet));
}
if (!Members.IsLoggedIn())
{
response.Success = false;
response.Msg = "请先进行登录过在进行补充信息";
}
else if (!ModelState.IsValid)
{
foreach (var item in ModelState)
{
if (item.Value.Errors.Count > 0)
{
response.Success = false;
response.Msg = item.Value.Errors.FirstOrDefault().ErrorMessage;
}
}
}
else
{
IMember member = Services.MemberService.GetById(Members.GetCurrentMemberId());
IContent contentchIps = Services.ContentService.GetById(chipsId.Value);
contentchIps.SetValue("isRefund", true);
contentchIps.SetValue("isOk", false);
IContentType ct = Services.ContentTypeService.GetContentType("Refunddocumnet");
IContent content = Services.ContentService.CreateContent(member.Name, ct.Id, "Refunddocumnet");
content.SetValue("member", member.Id.ToString());
content.SetValue("chipsid", chipsId.Value.ToString());
content.SetValue("username", model.Name);
content.SetValue("bankName", model.BankName);
content.SetValue("bankNumber", model.BankNumber);
content.SetValue("bankNamedetail", model.BankDetail);
content.SetValue("amount", contentchIps.GetValue <string>("amount"));
content.SetValue("isOk", false);
Services.ContentService.Save(contentchIps);
Services.ContentService.Save(content);
response.Success = true;
response.Msg = "您已经成功提交退款申请";
response.RedirectUrl = "/memberinfo";
}
return(Json(response, JsonRequestBehavior.AllowGet));
}
public IActionResult Withdraw(int id)
{
if (HttpContext.Session.GetString("UserRole") == null)
{
return(RedirectToAction("Login", "Login"));
}
WithdrawViewModel withdrawViewModel = new WithdrawViewModel()
{
AccountId = id
};
return(View(withdrawViewModel));
}
public void ValidatexNegativeWithdrawal()
{
var viewModel = new WithdrawViewModel
{
Amount = -20,
Balance = 2000,
Error = "Invalid amount"
};
var actionResult = sut.Withdraw(viewModel, 1, -20);
var viewResult = actionResult as ViewResult;
Assert.IsFalse(viewResult.ViewData.ModelState.IsValid);
}
public void ValidateAWithdrawal()
{
var viewModel = new WithdrawViewModel
{
Amount = 20,
Balance = 2000,
Error = "Invalid amount"
};
var actionResult = sut.Withdraw(viewModel, 1, 20);
var viewResult = actionResult as RedirectToActionResult;
Assert.AreEqual("AccountIndex", viewResult.ActionName);
}
public async Task <HttpResponseMessage> Withdraw(WithdrawViewModel model)
{
using (HttpClient client = clientAddress.getTransactionService())
{
var contentType = new MediaTypeWithQualityHeaderValue("application/json");
client.DefaultRequestHeaders.Accept.Add(contentType);
StringContent content = new StringContent(JsonConvert.SerializeObject(model), Encoding.UTF8, "application/json");
var response = await client.PostAsync("api/Transaction/withdraw", content);
return(response);
}
}
public void Retrieve(WithdrawViewModel model)
{
var total = 0;
var account = Accounts.Where(a => a.AccountNumber == model.Account).FirstOrDefault();
foreach (var item in model.Denominator)
{
Dispense(item.Unit, item.Currency, model.Account);
total = total + (item.Unit * item.Currency);
}
printReceipt(total, model.Account);
account.Balance -= total;
}
public ActionResult Withdraw([Bind(Prefix = "withdrawModel")] WithdrawViewModel model)
{
ResponseModel responseModel = new ResponseModel();
if (!Members.IsLoggedIn())
{
responseModel.Success = false;
responseModel.Msg = "请先进行登录过在进行补充信息";
}
else if (!ModelState.IsValid)
{
foreach (var item in ModelState)
{
if (item.Value.Errors.Count > 0)
{
responseModel.Success = false;
responseModel.Msg = item.Value.Errors.FirstOrDefault().ErrorMessage;
}
}
}
else
{
IMember member = Services.MemberService.GetById(Members.GetCurrentMemberId());
if (!member.GetValue <bool>("verified"))
{
responseModel.Msg = "请先进行实名认证，方可进行提现申请";
responseModel.Success = false;
responseModel.RedirectUrl = "/memberinfo/verified";
}
else
{
IContentType ct = Services.ContentTypeService.GetContentType("WithdrawElement");
IContent content = Services.ContentService.CreateContent(model.Name + "[" + model.Amount + "]", ct.Id, "WithdrawElement");
content.SetValue("memberId", Members.GetCurrentMemberId().ToString());
content.SetValue("amount", model.Amount.ToString());
content.SetValue("memberName", model.Name);
content.SetValue("bankName", model.BankName);
content.SetValue("bankNumber", model.BankNumber);
content.SetValue("bankDetail", model.BankDetail);
content.SetValue("isCheck", false);
content.SetValue("okassets", Members.GetCurrentMember()["okassets"]);
Services.ContentService.Save(content);
EventHandlers.CustomRaiseEvent.RaiseContentCreated(content);
responseModel.Msg = "恭喜你！已经成功提交提现申请";
responseModel.Success = true;
}
}
return(Json(responseModel, JsonRequestBehavior.AllowGet));
}
public bool Withdraw(WithdrawViewModel model)
{
var ser = new TransactionService();
try
{
ser.Retrieve(model);
return(true);
}
catch (Exception e)
{
ser.printErrorStatement(model.Account, e.Message);
return(false);
}
}
public ActionResult Create(WithdrawViewModel model)
{
try
{
bool result = MachineManager.GetMachineInstance().InvokeWithdrawCommand(model.Amount);
if (result)
{
TempData["message"] = "Successfull!";
TempData["id"] = model.Amount;
return RedirectToAction("Receipt");
}
else
{
TempData["message"] = "Unsucessfully!";
return RedirectToAction("Create");
}
}
catch
{
return View();
}
}
public ActionResult Create(WithdrawViewModel model, string details, string ok)
{
if (string.IsNullOrWhiteSpace(details))
{
using (ApplicationDbContext dataContext = new ApplicationDbContext())
{
using (var trans = dataContext.Database.BeginTransaction())
{
try
{
BankAccount account = dataContext.Accounts.First(a => a.WithdrawAccount == true && a.User.UserName == User.Identity.Name);
if (model.Amount == 0)
{
throw new Exception("Det är inte möjligt att ta ut 0 kr.");
}
else
{
if (model.Amount % 100 == 0)
{
if (account.Balance > model.Amount)
{
account.Balance -= model.Amount;
dataContext.Transactions.Add(new Transaction { TransactionTime = DateTime.Now, Account = account, Balance = account.Balance, Amount = model.Amount, TransactionType = "Uttag" });
dataContext.SaveChanges();
trans.Commit();
Session["fivehundreds"] = Convert.ToInt32((model.Amount - (model.Amount % 500)) / 500);
Session["hundreds"] = Convert.ToInt32((model.Amount - ((int)Session["fivehundreds"] * 500)) / 100);
using (ApplicationDbContext dContext = new ApplicationDbContext())
{
Money hundredbills = dataContext.Money.Where(m => m.Denominator == 100).First();
Money fivehundredbills = dataContext.Money.Where(m => m.Denominator == 500).First();
hundredbills.RemainingPieces -= (int)Session["hundreds"];
fivehundredbills.RemainingPieces -= (int)Session["fivehundreds"];
dataContext.ClickLogs.Add(new ClickLog { Time = DateTime.Now, TurnOut = "Lyckades", Amount = model.Amount, EventType = "Uttag", UserName = User.Identity.Name });
dataContext.SaveChanges();
}
}
else
{
throw new Exception("Det saknas pengar på kontot");
}
}
else
{
throw new Exception("Observera att du endast kan ta ut pengar i hundratal");
}
}
}
catch (Exception ex)
{
trans.Rollback();
string msg = (ex.Message == "Det saknas pengar på kontot" ? "Användaren försökte ta ut mer pengar än vad som fanns på kontot" : $"Användaren försökte ta ut {model.Amount} kr");
dataContext.ClickLogs.Add(new ClickLog { Time = DateTime.Now, TurnOut = msg, Amount = model.Amount, EventType = "Uttag", UserName = User.Identity.Name });
dataContext.SaveChanges();
ModelState.AddModelError("", ex);
return RedirectToAction("Create", "Withdraw", new { errormsg = ex.Message });
}
}
}
return RedirectToAction("Create", "ResultScreen", new { fivehundreds = (int)Session["fivehundreds"], hundreds = (int)Session["hundreds"], print = model.PrintReceipt, mail = model.EmailReceipt });
}
else
{
return RedirectToAction("Index", "BankAccount");
}
}
