public void ExecuteTest()
{
Client client = new Client("Jan", "Nowak", "01234567891");
BankAccount bankAccount = new BankAccount("1", new InterestZero(), 1000, client);
Withdraw withdraw = new Withdraw(bankAccount, 100);
withdraw.Execute();
Assert.AreEqual(900, bankAccount.GetSaldo());
}
public void OnWithdrawDoubleClicked(object sender, EventArgs e)
{
if (withdrawView.DataGridView.CurrentRow.Index != -1)
{
withdraw.WithdrawID = Convert.ToInt32(withdrawView.DataGridView.CurrentRow.Cells["withdrawID"].Value);
withdraw = services.UpdateSelectedWithdraw(withdraw);
withdrawView.TxtWithdrawAmount = withdraw.WithdrawAmount.ToString();
withdrawView.TxtWithdrawDate = withdraw.WithdrawDate.ToShortDateString();
withdrawView.TxtCategory = withdraw.WithdrawName;
}
}
public async Task <IEnumerable <Withdraw> > QueryWithdraw(Withdraw withdraw)
{
using (IDbConnection conn = DBConnection.CreateConnection())
{
conn.Open();
var status = (int)withdraw.Status;
var withdrawRet = await conn.QueryAsync <Withdraw>(Procedure.GetWithdrawByUserId, new { withdraw.UserId, status = -1 }, null, null, CommandType.StoredProcedure);
return(withdrawRet);
}
}
public async Task Handle(Withdraw message, IMessageHandlerContext context)
{
if (Data.Balance < message.Amount)
{
await Causes(new InsufficientBalance(message.TransactionId, message.AccountId, message.Amount, Data.Balance), context);
return;
}
await Causes(new AmountWithdrawn(message.TransactionId, message.AccountId, message.Amount), context);
}
public async void CreateWithdrawal()
{
//1.New Withdraw Preparation
Withdraw withdraw = new Withdraw();
withdraw.Description = product.text;
withdraw.AmountInSatoshi = int.Parse(amount.text);
//2.Create withdraw with ZEBEDEE backend and get lnurl
await zbdClient.WithDrawAsync(withdraw, handleWithdrawal);
}
public ActionResult Edit([Bind(Include = "Id,PassBookId,Acronym,WithdrawDate,Amount,Status")] Withdraw withdraw)
{
if (ModelState.IsValid)
{
db.Entry(withdraw).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.PassBookId = new SelectList(db.PassBooks, "Id", "Acronym", withdraw.PassBookId);
return(View(withdraw));
}
public async Task <IActionResult> Withdraw([FromBody] Withdraw command)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
await DispatchAsync(command);
return(NoContent());
}
public ActionResult Withdraw(Withdraw withdraw)
{
withdraw.Username = Session["username"].ToString();
if (Banking.WithDraw(withdraw))
{
TempData["Msg"] = "🎉 Withdraw Successful !!!";
return(RedirectToAction("Main"));
}
TempData["Msg"] = "😢 Oops! Something went wrong please try again later.";
return(RedirectToAction("Main"));
}
public async Task<IActionResult> Withdraw([FromRoute]Guid id, [FromBody]WithdrawDto dto, CancellationToken cancellationToken = default)
{
if (null == dto)
return BadRequest();
var currency = Currency.FromCode(dto.CurrencyCode);
var amount = new Money(currency, dto.Amount);
var command = new Withdraw(id, amount);
await _mediator.Publish(command, cancellationToken);
return Ok();
}
public ActionResult Edit([Bind(Include = "Id,DepositeId,TransectionId,Amount,Date,BankAccountId")] Withdraw withdraw)
{
if (ModelState.IsValid)
{
db.Entry(withdraw).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.BankAccountId = new SelectList(db.BankAccounts, "Id", "CardNumber", withdraw.BankAccountId);
return(View(withdraw));
}
public void DepositAndWithdrawTest_TestsIfThingsGoAsExpectedWhenWithdrawIsMadeAfterDeposit_ChecksBalanceToVerify()
{
// Scenario: Confirmed Deposit --> Withdraw --> Check Balance
IFundsValidationService fundsValidationService = (IFundsValidationService)ContextRegistry.GetContext()["FundsValidationService"];
IFundsPersistenceRepository fundsPersistenceRepository = (IFundsPersistenceRepository)ContextRegistry.GetContext()["FundsPersistenceRepository"];
IBalanceRepository balanceRepository = (IBalanceRepository)ContextRegistry.GetContext()["BalanceRepository"];
IDepositIdGeneratorService depositIdGeneratorService = (IDepositIdGeneratorService)ContextRegistry.GetContext()["DepositIdGeneratorService"];
IWithdrawFeesRepository withdrawFeesRepository = (IWithdrawFeesRepository)ContextRegistry.GetContext()["WithdrawFeesRepository"];
AccountId accountId = new AccountId(123);
Currency currency = new Currency("BTC", true);
// Deposit
Deposit deposit = new Deposit(currency, depositIdGeneratorService.GenerateId(), DateTime.Now,
DepositType.Default, 1.4m, 0, TransactionStatus.Pending, accountId,
new TransactionId("123"), new BitcoinAddress("bitcoin123"));
deposit.IncrementConfirmations(7);
fundsPersistenceRepository.SaveOrUpdate(deposit);
// Retrieve balance
Balance balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId);
Assert.IsNull(balance);
bool depositResponse = fundsValidationService.DepositConfirmed(deposit);
Assert.IsTrue(depositResponse);
// Check balance
balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId);
Assert.IsNotNull(balance);
Assert.AreEqual(balance.CurrentBalance, deposit.Amount);
Assert.AreEqual(balance.AvailableBalance, deposit.Amount);
Assert.AreEqual(balance.PendingBalance, 0);
// Withdraw
Withdraw validateFundsForWithdrawal = fundsValidationService.ValidateFundsForWithdrawal(accountId, currency,
1.3M, new TransactionId("transaction123"), new BitcoinAddress("bitcoin123"));
Assert.IsNotNull(validateFundsForWithdrawal);
bool withdrawalExecuted = fundsValidationService.WithdrawalExecuted(validateFundsForWithdrawal);
Assert.IsTrue(withdrawalExecuted);
WithdrawFees withdrawFee = withdrawFeesRepository.GetWithdrawFeesByCurrencyName(currency.Name);
// Check balance
balance = balanceRepository.GetBalanceByCurrencyAndAccountId(currency, accountId);
Assert.IsNotNull(balance);
Assert.AreEqual(Math.Round(1.4M - 1.3M, 5), Math.Round(balance.CurrentBalance, 5));
Assert.AreEqual(Math.Round(1.4M - 1.3M, 5), Math.Round(balance.AvailableBalance, 5));
Assert.AreEqual(0, balance.PendingBalance);
}
public void withdraw_Transaction(Withdraw withdraw)
{
try
{
if (can_Withdraw(withdraw))
{
db.Withdrawals.Add(withdraw);
db.SaveChanges();
}
}
catch (Exception ex) { }
}
public async Task <bool> Discard(int id)
{
Withdraw withdraw = await GetByIdAsync <Withdraw>(id);
if (withdraw.Status != WithdrawStatus.APPLY)
{
return(false);
}
withdraw.Status = WithdrawStatus.DISCARDED;
withdraw.OperateTime = DateTime.Now;
return(await SaveChangesAsync());
}
public void Withdraw(Withdraw withdraw)
{
if (!BContext.Accounts.Find(withdraw.AccountId).isLocked)
{
if (BContext.Accounts.Single(a => a.Id == withdraw.AccountId).Balance >= withdraw.Amount)
{
BContext.Withdraws.Add(withdraw);
BContext.Accounts.Single(a => a.Id == withdraw.AccountId).Balance -= withdraw.Amount;
BContext.SaveChanges();
}
}
}
public void AddWithdrawal(Withdraw withdraw)
{
try
{
if (CanWithdraw(withdraw))
{
ModelsContext.Withdrawals.Add(withdraw);
ModelsContext.SaveChanges();
}
}
catch (Exception ex) { }
}
public static string WithdrawalFieldModel(Withdraw withdraw)
{
WithdrawalFields fields = new WithdrawalFields
{
id = new TransactionId {
stringValue = withdraw.id
},
email = new Email {
stringValue = withdraw.user_email
},
local_id = new LocalId {
stringValue = withdraw.user_local
},
username = new Username {
stringValue = withdraw.user_name
},
bank_name = new BankName {
stringValue = withdraw.bank_name
},
bank_code = new BankCode {
stringValue = withdraw.bank_code
},
account_number = new AccountNumber {
stringValue = withdraw.account_number
},
amount = new Amount {
doubleValue = withdraw.amount
},
status = new Status {
stringValue = withdraw.status
},
transaction_id = new TransactionId {
stringValue = withdraw.transaction_id
},
reference = new TransactionId {
stringValue = withdraw.reference
},
};
WithdrawalRootObject rootObject = new WithdrawalRootObject
{
fields = fields
};
fsData data;
serializer.TrySerialize(typeof(WithdrawalRootObject), rootObject, out data).AssertSuccessWithoutWarnings();
string post_data = data.ToString();
return(post_data);
}
public async void CreateWithdrawal()
{
//1.New Invoice Preparation
//1.インボイス オブジェクトに必要項目をセットする
Withdraw withdrawReq = new Withdraw();
withdrawReq.Description = product.text;
withdrawReq.AmountInSatoshi = int.Parse(amount.text);
//2.Create Invoice with initial data and get the full invoice
//2.Zebedee Serverにインボイスデータをサブミットして、インボイスの詳細データを取得する。
await zbdClient.WithDrawAsync(withdrawReq, handleWithdrawal);
}
public void DoOperationTest2()
{
string bankId = Bank.GetFreeBanktId();
Bank bank = new Bank(bankId);
Client client = new Client("Jan", "Nowak", "01234567891");
BankAccount bankAccount = new BankAccount("1", new InterestZero(), 1000, client);
Withdraw withdraw = new Withdraw(bankAccount, 100);
Assert.AreEqual(0, bank.GetOperationsList().Count);
bank.DoOperation(withdraw);
Assert.AreEqual(1, bank.GetOperationsList().Count);
}
public SelectList GetAllAccounts(Withdraw withdraw)
{
//populate list of Accounts
var query = from b in db.Accounts
orderby b.AccountType
select b;
List <BankAccount> allAccounts = query.ToList();
SelectList list = new SelectList(allAccounts, "BankAccountID", "Name", withdraw.Account.BankAccountID);
return(list);
}
//Withdraw without Callback
public async Task <WithdrawResponse> WithDrawAsync(Withdraw withdraw)
{
//Satoshi to milli satoshi
WithdrawData withdrawRequest = new WithdrawData();
withdrawRequest.Amount = withdraw.AmountInSatoshi * 1000;
withdrawRequest.Name = withdraw.Name;
withdrawRequest.Description = withdraw.Description;
WithdrawResponse withdrawResponse = await zbdService.WithdrawAsync(withdrawRequest);
return(withdrawResponse);
}
public void CommitWithdrawFailTest_ChecksThatWithdrawEventIsSubmittedAsExpectedToTheCoinClientService_VerifiesThroughVariablesValues()
{
var mockFundsRepository = new MockFundsRepository();
var mockWithdrawRepository = new MockWithdrawRepository();
var mockBitcoinClientService = new MockBitcoinClientService();
var mockLitecoinClientService = new MockLitecoinClientService();
ClientInteractionService clientInteractionService = new ClientInteractionService(mockFundsRepository, mockWithdrawRepository,
mockBitcoinClientService, mockLitecoinClientService);
Withdraw withdraw = null;
clientInteractionService.CommitWithdraw(withdraw);
}
public async Task Validate_Should_Fail_When_Course_Does_Not_Exists()
{
var unitOfWork = Substitute.For <ISchoolUnitOfWork>();
var sut = new WithdrawValidator(unitOfWork);
var command = new Withdraw(Guid.NewGuid(), Guid.NewGuid());
var result = await sut.ValidateAsync(command, CancellationToken.None);
result.Should().NotBeNull();
result.Success.Should().BeFalse();
result.Errors.Should().Contain(e =>
e.Context == nameof(Withdraw.CourseId) && e.Message.Contains(command.CourseId.ToString()));
}
public async Task <bool> SaveAsycn(Withdraw model, WithdrawType withdrawType, Member member)
{
PayRecord payRecord = new PayRecord
{
MemberId = model.MemberId,
OrderNo = "Withdraw:" + model.Id,
Description = $"用户{member.Name}于{model.OperateTime.ToFormat()}提现",
Amount = -(model.Score - model.Score * model.TaxPercentage),
PayType = withdrawType?.Name + model.Description
};
return(await SaveAsync(payRecord));
}
public async void DoWithdrawal()
{
QRCodePanel.SetActive(true);
//1.New Withdrawal Preparation
Withdraw withdraw = new Withdraw();
withdraw.Description = "ZEBEDEE SDK DEMO GAME";
withdraw.AmountInSatoshi = totalSats;
//2.Create Invoice with initial data and get the full invoice
await zbdClient.WithDrawAsync(withdraw, handleWithdrawal);
}
public async Task PatchWithdrawal(Withdraw request)
{
if (ModelState.IsValid)
{
var accounts = await GetActor <AccountCoordinator>();
accounts.Tell(new AccountCommands.Withdraw(request.AccountId, request.Amount), ActorRefs.NoSender);
}
else
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
}
public void WithdrawLimitScenario14Test_ChecksIfTheScenarioProceedsAsExpected_VerifiesThroughReturnedValue()
{
// Scenario: DailyLimit = 500/1000, MonthlyLimit = 4500/5000 with insufficient balance
IWithdrawLimitEvaluationService withdrawLimitEvaluationService = new WithdrawLimitEvaluationService();
Currency currency = new Currency("XBT");
AccountId accountId = new AccountId(123);
decimal dailyLimit = 1000;
decimal monthlyLimit = 5000;
// Balance is less than the calculated maximum threshold foor the remaining quantity from the daily limit used
decimal availableBalance = 500 - 0.09m;
decimal currentBalance = 500 - 0.09m;
// Amount that can be safely withdrawn
decimal safeAmount = availableBalance;
decimal fee = 0.001m;
List <Withdraw> withdraws = new List <Withdraw>();
Withdraw withdraw = new Withdraw(currency, "withdrawid123", DateTime.Now.AddDays(-29), WithdrawType.Bitcoin,
4000, fee, TransactionStatus.Pending, accountId,
new BitcoinAddress("bitcoin123"));
Withdraw withdraw2 = new Withdraw(currency, "withdrawid123", DateTime.Now.AddMinutes(-29), WithdrawType.Bitcoin,
500, fee, TransactionStatus.Pending, accountId,
new BitcoinAddress("bitcoin123"));
withdraws.Add(withdraw);
withdraws.Add(withdraw2);
WithdrawLimit withdrawLimit = new WithdrawLimit("Tier0", dailyLimit, monthlyLimit);
bool evaluationResponse = withdrawLimitEvaluationService.EvaluateMaximumWithdrawLimit(500, withdraws,
withdrawLimit, availableBalance, currentBalance);
Assert.IsFalse(evaluationResponse);
Assert.AreEqual(1000, withdrawLimitEvaluationService.DailyLimit);
Assert.AreEqual(5000, withdrawLimitEvaluationService.MonthlyLimit);
Assert.AreEqual(500 + fee, withdrawLimitEvaluationService.DailyLimitUsed);
Assert.AreEqual(4500 + fee * 2, withdrawLimitEvaluationService.MonthlyLimitUsed);
Assert.AreEqual(Math.Round(availableBalance, 5), withdrawLimitEvaluationService.MaximumWithdraw);
Assert.AreEqual(0, withdrawLimitEvaluationService.WithheldAmount);
// Withdraw below the threshold limit
evaluationResponse = withdrawLimitEvaluationService.EvaluateMaximumWithdrawLimit(safeAmount - 10, withdraws,
withdrawLimit, availableBalance, currentBalance);
Assert.IsTrue(evaluationResponse);
Assert.AreEqual(1000, withdrawLimitEvaluationService.DailyLimit);
Assert.AreEqual(5000, withdrawLimitEvaluationService.MonthlyLimit);
Assert.AreEqual(500 + fee, withdrawLimitEvaluationService.DailyLimitUsed);
Assert.AreEqual(4500 + fee * 2, withdrawLimitEvaluationService.MonthlyLimitUsed);
Assert.AreEqual(Math.Round(availableBalance, 5), withdrawLimitEvaluationService.MaximumWithdraw);
Assert.AreEqual(0, withdrawLimitEvaluationService.WithheldAmount);
}
public async Task <TransactionsResult> WithdrawAsync(WithdrawRequest withdrawRequest)
{
var transactionsResult = new TransactionsResult
{
AccountIban = withdrawRequest.AccountIban,
Amount = withdrawRequest.Amount,
Success = false,
ErrorMessage = string.Empty,
TransactionsType = "Withdraw",
TransactionsDate = DateTime.UtcNow
};
if (withdrawRequest.Amount <= 0)
{
transactionsResult.ErrorMessage = "Withdraw amount is incorret";
return(transactionsResult);
}
var account = await accountRepository.GetByAccountIbanAsync(withdrawRequest.AccountIban);
if (account == null)
{
transactionsResult.ErrorMessage = "Account does not exists";
return(transactionsResult);
}
if (account.Balance - withdrawRequest.Amount < 0)
{
transactionsResult.ErrorMessage = "Account balance less than withdraw amount";
return(transactionsResult);
}
account.Balance -= withdrawRequest.Amount;
await accountRepository.UpdateAccountAsync(account);
var withdraw = new Withdraw
{
WithdrawId = Guid.NewGuid(),
AccountId = account.AccountId,
Amount = withdrawRequest.Amount,
Timestamp = DateTime.UtcNow
};
await withdrawRepository.AddWithdrawAsync(withdraw);
transactionsResult.Balance = account.Balance;
transactionsResult.Success = true;
return(transactionsResult);
}
public void Test_Transfer_ThenWithdrawFromTheSecondAccount_ThenRollback()
{
// Create firstAccount with Initial Balance 2000
var initialAccount1 = new Account()
{
Balance = 2000, AccountGuid = Guid.NewGuid()
};
// Create secondAccount with Initial Balance 100
var initialAccount2 = new Account()
{
Balance = 100, AccountGuid = Guid.NewGuid()
};
// Create a transfer request of 700 from firstAccount to secondAccount
var transfer = new Transfer(initialAccount1, initialAccount2, 700);
_transactionManager.AddTransaction(transfer);
// Run ProcessPendingTransactions() to process Pending TransactionRequests
_transactionManager.ProcessPendingTransactions();
// Balance Check : FirstAccount -> 1300
Assert.AreEqual(initialAccount1.Balance, 1300);
// Balance Check : SecondAccount -> 800
Assert.AreEqual(initialAccount2.Balance, 800);
// Create a withdraw request of 600 from the secondAccount
var withdraw = new Withdraw(initialAccount2, 600);
_transactionManager.AddTransaction(withdraw);
// Run ProcessPendingTransactions() to process Pending TransactionRequests
_transactionManager.ProcessPendingTransactions();
// Perform a Rollback with the transaction Id of the transfer which is made (Rollback should not be executed because of balance constraint)
_transactionManager.RollbackTransaction(transfer.TransactionGuid);
// Perform a Rollback with the transaction Id of the withdraw which was made
_transactionManager.RollbackTransaction(withdraw.TransactionGuid);
// Run ProcessPendingTransactions() to process Pending TransactionRequests
_transactionManager.ProcessPendingTransactions();
// Balance Check : FirstAccount -> 2000
Assert.AreEqual(initialAccount1.Balance, 2000);
// Balance Check : SecondAccount -> 100
Assert.AreEqual(initialAccount2.Balance, 100);
}
// GET: Withdraws/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Withdraw withdraw = db.Withdraws.Find(id);
if (withdraw == null)
{
return(HttpNotFound());
}
return(View(withdraw));
}
/// <summary>
/// Saveas a withdraw to database and starts teh timer after which the withrawal is submitted to CoinClientService
/// </summary>
/// <returns></returns>
public bool CommitWithdraw(Withdraw withdraw)
{
if (withdraw != null)
{
Log.Debug(string.Format("New Withdraw request received, starting withdraw timer: Account ID = {0}, Currency = {1}", withdraw.AccountId.Value, withdraw.Currency.Name));
Timer timer = new Timer(_withdrawSubmissioInterval);
timer.Elapsed += OnTimerElapsed;
//timer.Enabled = true;
timer.Start();
_withdrawTimersDictionary.Add(timer, withdraw);
return(true);
}
throw new NullReferenceException(string.Format("Withdraw received to ClientInteractionService is null"));
}
