private TransactionResponseModel Deposit(DepositViewModel model, IUnitOfWork unit)
{
var failureResponse = new TransactionResponseModel
{
IsSuccessful = false
};
var account = unit.Repository <Account>().Get().SingleOrDefault(a => a.AccountNumber == model.AccountNumber);
if (account != null)
{
if (model.Amount < decimal.MaxValue - account.Balance)
{
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.SystemError;
return(failureResponse);
}
failureResponse.Message = Message.AccountIsInvalid;
return(failureResponse);
}
public async Task <IActionResult> Post([FromBody] DepositViewModel model)
{
Deposit deposit = _mapper.Map <DepositViewModel, Deposit>(model);
deposit.Ativo = false;
if (model.UserWallet != null)
{
Wallet wallet = await _appWalletService.GetWalletByGuidAsync(model.Guid);
deposit.WalletId = wallet.Id;
deposit.BankId = null;
}
else
{
deposit.BankId = model.BankId;
}
try
{
await _appDepositService.InsertAsync(deposit);
}
catch (Exception e)
{
throw;
}
return(Ok());
}
public ActionResult Index(DepositSearchModel depositSearchModel)
{
try
{
DepositViewModel dvm = new DepositViewModel();
if (depositSearchModel.StartDateString != null && depositSearchModel.StartDateString != "")
{
depositSearchModel.StartDate = DateTime.ParseExact(depositSearchModel.StartDateString, "dd-MM-yyyy", CultureInfo.InvariantCulture);
//depositSearchModel.StartDate = Convert.ToDateTime(depositSearchModel.EndDate).AddDays(1).AddMilliseconds(-1);
}
if (depositSearchModel.EndDateString != null && depositSearchModel.EndDateString != "")
{
depositSearchModel.EndDate = DateTime.ParseExact(depositSearchModel.EndDateString, "dd-MM-yyyy", CultureInfo.InvariantCulture).AddDays(1).AddMilliseconds(-1);
//depositSearchModel.EndDate = Convert.ToDateTime(depositSearchModel.EndDate).AddDays(1).AddMilliseconds(-1);
}
dvm.DepositModelList = dal.GetDeposits(depositSearchModel);
var bankAccount = dal.GetBanks();
ViewBag.BankAccount = new SelectList(bankAccount, "Id", "BankName");
var gameType = dal.GetGameTypes();
ViewBag.GameType = new SelectList(gameType, "Id", "GameType");
var status = from Status s in Enum.GetValues(typeof(Status)) select new { ID = (int)s, Name = s.ToString() };
ViewBag.Status = new SelectList(status, "ID", "Name");
return(View(dvm));
}
catch
{
Session["message"] = "Unable to perform this request";
Session["requestStatus"] = "Error";
return(RedirectToAction("Index", "Deposit"));
}
}
/* DEPOSIT */
// Skapar upp Vy-modellen och redirectar
public IActionResult MakeDeposit(int accountId)
{
DepositViewModel model = new DepositViewModel();
model.Account = accountId;
return(View(model));
}
public async Task <IActionResult> Deposit(DepositViewModel model)
{
TransactionStatusViewModel transactionStatus = new TransactionStatusViewModel();
try
{
var response = await _transactionProvider.Deposit(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 async Task <IActionResult> Deposit([FromBody] DepositViewModel depositViewModel)
{
try
{
if (!ModelState.IsValid)
{
ModelState.AddModelError("DepositViewModelInvalid", "Informe um modelo válido");
return(BadRequest(ModelState));
}
var account = await _accountAppService.GetByAccountNumberAndAgencyAsync(depositViewModel.AccountNumber, depositViewModel.Agency);
if (account == null)
{
return(NotFound("Conta não encontrada"));
}
await _accountAppService.Deposit(account, depositViewModel.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 depósito. {ex.Message}"));
}
}
public SearchForStore(DepositViewModel viewModel)
{
InitializeComponent();
DataContext = viewModel;
_viewModel = viewModel;
_viewModel.StoreList.Clear();
}
public SearchBankDeposit(DepositViewModel viewModel)
{
InitializeComponent();
DataContext = viewModel;
_viewModel = viewModel;
_viewModel.MainRowList.Clear();
}
public async Task <IActionResult> PutTransaction(Guid CommonCode, DepositViewModel transaction)
{
if (CommonCode != transaction.CommonCode)
{
return(BadRequest());
}
var existingTransaction = await _context.Transactions.Where(x => x.CommonCode == CommonCode).ToListAsync();
if (existingTransaction.Count > 0)
{
var existingAccount = await _context.Accounts.ToListAsync();
var updateableTransaction = existingTransaction.Where(x => x.AccountId == x.AccountId).ToList();
updateableTransaction.ForEach(x => x.Amount = x.Account.AccountPercent * x.Amount / 100);
await _context.SaveChangesAsync();
foreach (var item in existingTransaction)
{
if (existingAccount.Any(x => x.AccountId == item.AccountId))
{
_context.Entry(item).State = EntityState.Modified;
await _context.SaveChangesAsync();
}
}
}
else
{
return(NotFound());
}
return(NoContent());
}
public IActionResult Deposit(DepositViewModel model)
{
if (ModelState.IsValid)
{
var command = new DepositCommand()
{
AccountId = model.AccountId,
Amount = model.Amount
};
var query = new DepositHandler().Handler(command);
if (query.IsCompletedSuccessfully)
{
TempData["Success"] = $"{model.Amount.ToString("C")} deposited to account";
return(View());
}
else
{
TempData["Error"] = $"Deposit failed";
return(View());
}
}
else
{
return(NotFound());
}
}
public async Task <IActionResult> MakeADeposit(DepositViewModel deposit)
{
Customer customer = new Customer();
customer = await _context.customers.FirstOrDefaultAsync(c => c.FirstName == deposit.ClientFirstName && c.LastName == deposit.ClientLastName);
if (customer == null)
{
return(NotFound());
}
var accounts = await _context.accounts.ToListAsync();
bool transaction_success = false;
foreach (var client_account in accounts)
{
if (client_account.Id.Equals(deposit.AccountId))
{
transaction_success = true;
client_account.Account_Balance += deposit.Amount;
break;
}
}
if (transaction_success)
{
await _context.SaveChangesAsync();
return(View("Success"));
}
return(View("Failed"));
}
//Deposit adds money to current user state
public static bool Deposit(DepositViewModel deposit)
{
bool flag = false;
if (deposit.Amount <= 0)
{
flag = false;
}
else
{
flag = true;
using (NmoorEntity db = new NmoorEntity())
{
Transaction transaction = new Transaction();
var amount = db.User.Where(u => u.username.Equals(deposit.Username)).FirstOrDefault();
amount.balance += deposit.Amount;
transaction.username = deposit.Username;
transaction.transactionType = "Deposit";
transaction.amount = deposit.Amount;
transaction.dateOfTransaction = DateTime.Now;
transaction.timeOfTransaction = TimeSpan.FromSeconds(60);
transaction.status = "Success";
db.Transaction.Add(transaction);
db.Entry(amount).State = EntityState.Modified;
db.SaveChanges();
}
}
return(flag);
}
public async Task <ActionResult> Create(AllDepositViewModel model)
{
try
{
DepositViewModel deposit = new DepositViewModel()
{
UserId = Convert.ToInt32(HttpContext.Session.GetInt32("IdUser")),
Ativo = false,
Value = model.ValorDeposito,
CurrencyId = model.Moedas,
UserWallet = model.WalletGuid,
Guid = model.WalletGuid,
BankId = model.SelectBancos
};
string json = JsonConvert.SerializeObject(deposit);
var resp = await ApiClient.PostAsync(GetUri("deposit"), Headers(json));
if (resp.IsSuccessStatusCode)
{
Success("Deposito realizado com sucesso");
return(RedirectToAction("Index", "Account"));
}
}
catch
{
}
Warning("Houve um problema, por favor tente novamente");
return(View(model));
}
public async Task Deposit_Given_InvalidAccount_Then_ReturnNotFound()
{
// Arrange
var mockService = new Mock <IAccountAppService>();
var invalidDepositViewModel = new DepositViewModel()
{
AccountNumber = 0,
Agency = 0
};
var sourceAccount = invalidDepositViewModel.AccountNumber;
mockService.Setup(service => service.GetByAccountNumberAndAgencyAsync(
invalidDepositViewModel.AccountNumber,
invalidDepositViewModel.Agency
)).ReturnsAsync((Account)null);
var controller = new AccountController(mockService.Object);
// Act
var result = await controller.Deposit(invalidDepositViewModel);
// Assert
Assert.IsType <NotFoundObjectResult>(result);
}
public async Task <bool> CreateDepositAsync(DepositViewModel model, AppUserViewModel user)
{
try
{
if (model.Amount < 0)
{
return(false);
}
var transaction = await _transactionService.CreateTransactionAsync(user.Id, model.Amount, TransactionType.Deposit);
if (transaction)
{
var deposit = _mapper.Map <DepositViewModel, Deposit>(model);
deposit.UserId = user.Id;
deposit.CreatedAt = DateTime.Now;
user.Balance += model.Amount;
await Add(deposit);
var us = _mapper.Map <AppUserViewModel, AppUser>(user);
DbContext.Users.Attach(us);
DbContext.Entry(us).State = EntityState.Modified;
return(await _unitOfWork.Commit());
}
}
catch (Exception e)
{
}
return(false);
}
public ActionResult NewDeposit(int ContributorId)
{
DepositViewModel dvm = new DepositViewModel();
dvm.ContributorId = ContributorId;
return(View(dvm));
}
public ActionResult Reports()
{
if (Session["userName"] != null)
{
DepositViewModel dvm = new DepositViewModel();
dvm.DepositModelList = dal.GetTodayDeposits();
var bankAccount = dal.GetBanks();
ViewBag.BankAccount = new SelectList(bankAccount, "Id", "BankName");
var gameType = dal.GetGameTypes();
ViewBag.GameType = new SelectList(gameType, "Id", "GameType");
var status = from Status s in Enum.GetValues(typeof(Status)) select new { ID = (int)s, Name = s.ToString() };
ViewBag.Status = new SelectList(status, "ID", "Name");
dvm.Message = Session["message"] != null ? Session["message"].ToString() : null;
dvm.RequestStatus = Session["requestStatus"] != null ? Session["requestStatus"].ToString() : null;
Session.Remove("message");
Session.Remove("requestStatus");
return(View(dvm));
}
else
{
return(RedirectToAction("Index", "Login"));
}
}
public async Task ReturnsViewResult_WhenCalled()
{
// Arrange
var cardServiceMock = new Mock <ICardService>();
var userBalServiceMock = new Mock <IUserBalanceService>();
var transactionServiceMock = new Mock <ITransactionService>();
var userManagerMock = SetupUserManagerMock();
var controller = SetupController(cardServiceMock, userBalServiceMock, transactionServiceMock, userManagerMock);
var model = new DepositViewModel()
{
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));
}
public IActionResult Post([FromBody] DepositViewModel deposit)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var transaction = new Transaction()
{
AccountId = _accountId,
Date = DateTime.Now,
Description = "Deposit",
Amount = deposit.Amount,
Type = TransactionType.SameAccount,
Status = TransactionStatus.Authorized,
};
_logger.LogInformation($"Someone asked for a deposit");
_repos.Transactions.Add(transaction);
_repos.SaveAndApply();
_dispatcher.Enqueue(transaction.TransactionId);
var receipt = new DepositReceiptViewModel()
{
TransactionId = transaction.TransactionId,
Amount = transaction.Amount
};
return(Ok(receipt));
}
public ActionResult Index()
{
ContentManagementController cmc = new ContentManagementController();
ViewBag.Contents = cmc.GetContentsByType(ContentType.DEPOSITTEXT).Contents;
DepositViewModel dvm = new DepositViewModel();
dvm.DepositModel = new DepositModel();
dvm.DepositModelList = dal.GetLatestDeposits();
dvm.WithdrawalModelList = dal.GetLatestWithdrawals();
dvm.BankDepositModelList = dal.GetBankDepositList();
ViewBag.TogelText = dal.GetContentsByType(ContentType.TOGELTEXT).Contents;
ViewBag.TogelDate = dal.GetContentsByType(ContentType.TOGELDATE).Contents;
ViewBag.TogelTime = dal.GetContentsByType(ContentType.TOGELTIME).Contents;
ViewBag.TogelTitle = dal.GetContentsByType(ContentType.TOGELTITLE).Contents;
var bankAccount = dal.GetBanks();
ViewBag.BankAccount = new SelectList(bankAccount, "Id", "BankName");
var gameType = dal.GetGameTypes();
ViewBag.GameType = new SelectList(gameType, "Id", "GameType");
return(View(dvm));
}
public IActionResult Deposit(DepositViewModel viewModel, int id, decimal amount)
{
if (ModelState.IsValid && amount > 0 && amount < 100001)
{
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;
dbTransaction.Date = DateTime.Now;
dbTransaction.Balance = currentBalance + amount;
dbTransaction.Operation = "Deposit";
dbTransaction.Type = "Credit";
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 ActionResult Deposit(DepositViewModel vm)
{
try
{
if (ModelState.IsValid)
{
var db = ApplicationDbContext.Create();
var checkingAccount = db.CheckingAccounts.Where(ac => ac.AccountNumber == vm.AccountNumber).FirstOrDefault();
if (checkingAccount == null)
{
throw new Exception("Invalid Account!!");
}
db.Transactions.Add(new Transaction {
Amount = vm.Amount, TimeStamp = DateTime.Now, CheckingAccountId = checkingAccount.ID
});
checkingAccount.Balance += vm.Amount;
db.SaveChanges();
//return RedirectToAction("Index");
/////
var checkAcc = db.CheckingAccounts.Where(a => a.AccountNumber == vm.AccountNumber).FirstOrDefault();
/////
return(RedirectToAction("Index", "Banking"));
}
return(View());
}
catch (Exception ex)
{
ViewBag.ErrorMessage = ex.ToString();
return(View());
}
}
public TransactionResponseModel Deposit(DepositViewModel model)
{
using (var unit = _unitOfWorkFactory.Create())
{
var result = Deposit(model, unit);
unit.Save();
return(result);
}
}
public ActionResult Edit([Bind(Include = "Id,AccountId,Date,PayerType,Amount,MethodId,PayerId,Description")] DepositViewModel deposit, int?id)
{
using (var dbTransaction = _db.Database.BeginTransaction())
{
try
{
if (id == null)
{
TempData["Toastr"] = Toastr.HttpNotFound;
return(RedirectToAction("Index"));
}
if (!_db.TransactionsInfos.Any(x => x.Id == id))
{
TempData["Toastr"] = Toastr.HttpNotFound;
return(RedirectToAction("Index"));
}
if (!ModelState.IsValid)
{
return(View(deposit));
}
var count = _db.TransactionsInfos
.Where(x => x.Id == id)
.Update(u => new TransactionsInfo
{
Date = deposit.Date,
AccountTo = deposit.AccountId,
PayerType = deposit.PayerType,
PayerId = deposit.PayerId,
Amount = deposit.Amount,
MethodId = deposit.MethodId,
Description = deposit.Description
});
if (count > 0)
{
_db.UpdateBalance(_db.BankAccounts.Find(deposit.AccountId), (double)deposit.Amount);
}
dbTransaction.Commit();
TempData["Toastr"] = Toastr.Updated;
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
dbTransaction.Rollback();
TempData["Toastr"] = Toastr.DbError(ex.Message);
return(RedirectToAction("Index"));
}
finally
{
ViewBag.Accounts = new SelectList(_db.BankAccounts.ToList(), "Id", "AccountName", deposit.AccountId);
ViewBag.PayerTypes = Common.ToSelectList <PayerType>(deposit.PayerType);
ViewBag.PaymentMethods = new SelectList(_db.PaymentMethods.ToList(), "Id", "MethodName", deposit.MethodId);
}
}
}
public IActionResult Deposit([FromRoute] int id)
{
var viewModel = new DepositViewModel();
var account = _dbContext.Accounts.FirstOrDefault(r => r.AccountId == id);
viewModel.Balance = account.Balance;
return(View(viewModel));
}
public ActionResult Deposit(int accountId)
{
var model = new DepositViewModel()
{
AccountID = accountId
};
return(View(model));
}
public async Task <IActionResult> Deposit([FromBody] DepositViewModel model)
{
string id = User.FindFirst("id").Value;
User user = await UserManager.FindByIdAsync(id);
if (user == null)
{
return(Unauthorized());
}
PaymentResult result = null;
switch (model.PaymentChannel)
{
case ChannelType.Paystack:
if (!Env.IsDevelopment())
{
string baseUrl = new Uri(HttpContext.Request.GetEncodedUrl()).GetBaseUrl();
Core.ONLINE_BASE_ADDRESS = baseUrl;
}
result = await PaymentService.UsePaystack(user, model.Amount);
break;
case ChannelType.Bank:
BankAccount account = user.BankAccounts.FirstOrDefault(b => b.IsActive && b.Id == model.UserBankAccountId);
// if (account == null) return NotFound("Invalid User Account Id");
BankAccount platformAccount = DataContext.PlatformAccount.BankAccounts.FirstOrDefault(b => b.IsActive && b.Id == model.PlatformBankAccountId);
if (platformAccount == null)
{
return(NotFound("Invalid Platform Account Id"));
}
result = await PaymentService.UseBank(user, model.Amount, model.Date, account, platformAccount, model.Description);
break;
}
switch (result.Status)
{
case PaymentStatus.Redirected:
return(Accepted(result.Message, result.Message));
case PaymentStatus.Success:
return(Ok());
case PaymentStatus.Pending:
return(Accepted());
default: return(BadRequest(result.Message));
}
}
public async Task <ActionResult> DepositMoney(DepositViewModel model, string userId)
{
var result = await _users.DepositMoney(model.Amount, userId);
if (result.Succeeded)
{
return(RedirectToAction("UserInfo"));
}
return(RedirectToAction("DepositMoney", new { message = result.Message }));
}
public async Task <TransactionResponseModel> DepositAsync(DepositViewModel model)
{
using (var unit = _unitOfWorkFactory.Create())
{
var result = await DepositAsync(model, unit);
var saveResult = unit.SaveAsync().Result;
return(HandleSaving(saveResult, result, unit, model.AccountNumber));
}
}
public async Task <IActionResult> DepositTransaction(DepositViewModel depositModel)
{
var response = await _httpClient.PostAsync <TransactionResponse>("api/Transaction/Deposit", depositModel);
if (!response.IsSuccess)
{
var errorMessage = ErrorMessageResolver.GetErrorMessage(response.ErrorCode);
return(RedirectToAction("Deposit", new { id = depositModel.AccountId, err = errorMessage }));
}
return(RedirectToAction("Detail", "Account", new { id = depositModel.AccountId }));
}