public void SuccessTest()
{
var service = new TransactionService();
var from = new Account(new decimal(1000.50), "Jonas Dixon");
var to = new Account(500, "Owen Moss");
var transaction_1 = new BankTransaction(1, from, to, 250);
var transaction_2 = new BankTransaction(2, from, to, 250);
var transaction_3 = new BankTransaction(3, from, to, 250);
var transaction_4 = new BankTransaction(4, from, to, 250);
service.AddTransaction(transaction_1);
service.AddTransaction(transaction_2);
service.AddTransaction(transaction_3);
service.AddTransaction(transaction_4);
if (service.HasTransactionsForExecuting)
{
service.ExecuteTransactions();
}
Assert.AreEqual(new decimal(0.50), from.Balance);
Assert.AreEqual(1500, to.Balance);
}
public void NotEnoughtMoneyTest()
{
var service = new TransactionService();
var from = new Account(new decimal(1000.50), "Jonas Dixon");
var to = new Account(500, "Owen Moss");
var transaction_1 = new BankTransaction(1, from, to, 250);
var transaction_2 = new BankTransaction(2, from, to, 1250);
service.AddTransaction(transaction_1);
service.AddTransaction(transaction_2);
if (service.HasTransactionsForExecuting)
{
service.ExecuteTransactions();
}
Assert.AreEqual(new decimal(750.50), from.Balance);
Assert.AreEqual(750, to.Balance);
Assert.IsTrue(service.HasTransactionsForExecuting);
if (service.HasTransactionsForExecuting)
{
service.ExecuteTransactions();
}
Assert.AreEqual(new decimal(750.50), from.Balance);
Assert.AreEqual(750, to.Balance);
}
public void RollbackTest()
{
var service = new TransactionService();
var from = new Account(new decimal(1000.50), "Jonas Dixon");
var to = new Account(500, "Owen Moss");
var transaction_1 = new BankTransaction(1, from, to, 200);
var transaction_2 = new BankTransaction(2, from, to, 300);
var transaction_3 = new BankTransaction(2, from, to, 400);
service.AddTransaction(transaction_1);
service.AddTransaction(transaction_2);
service.AddTransaction(transaction_3);
if (service.HasTransactionsForExecuting)
{
service.ExecuteTransactions();
}
Assert.AreEqual(new decimal(100.50), from.Balance);
Assert.AreEqual(1400, to.Balance);
Assert.IsFalse(service.HasTransactionsForExecuting);
service.RollbackTransaction(2);
Assert.AreEqual(new decimal(400.50), from.Balance);
Assert.AreEqual(1100, to.Balance);
}
private bool TryFindMatchingTransaction(
IList <Tuple <BankTransaction, BankTransaction> > creditCardPayments, IList <BankTransaction> otherTransactions, IDictionary <long, Queue <BankTransaction> > AmountsHash, BankTransaction secondTransaction)
{
long opposingAmount = secondTransaction.Amount * -1;
Queue <BankTransaction> queue = AmountsHash[opposingAmount];
while (queue.Count > 0)
{
// Get the oldest transaction in the queue.
BankTransaction firstTransaction = queue.Dequeue();
if (AreInTheSameTimeWindow(firstTransaction, secondTransaction))
{
// They are matching payments.
Tuple <BankTransaction, BankTransaction> tuple = new Tuple <BankTransaction, BankTransaction>(
item1: firstTransaction,
item2: secondTransaction);
creditCardPayments.Add(tuple);
return(true);
}
else
{
// The first transaction is too old.
// That means we should discart it because the next transaction we
// select from the outer loop will be newer and it will not be in
// the same time window either.
// The next transaction coming from the queue will be newer, that one could match.
otherTransactions.Add(firstTransaction);
}
}
// None of the transactions with opposing amounts are in the same time window.
return(false);
}
public async Task <AllBankRecords> Deposit(BankTransaction transaction)
{
var playerAccount = cache.Get <AllBankRecords>(transaction.PlayerName + "_Bank");
var turn = cache.Get <Clock>(transaction.PlayerName + "_Clock");
if (playerAccount == null)
{
throw new Exception("No bank account exists for provided player");
}
var clock = new Clock();
clock.PlayerName = turn.PlayerName;
var gameStatus = this.clockService.PlayerTurn(clock);
if (gameStatus == Constants.gameOver)
{
throw new Exception("Game Over");
}
playerAccount.Accounts.Balance += transaction.Price;
transaction.Status = Constants.deposit;
var bankRecords = new AllBankRecords()
{
};
bankRecords = playerAccount;
bankRecords.BankTransactions.Add(transaction);
bankRecords.CurrentTurn = turn.PlayerTurn + 1;
cache.Set(transaction.PlayerName + "_Bank", bankRecords, Constants.cacheTime);
return(bankRecords);
}
public async Task <ActionResult <BankTransaction> > PostBankTransaction(BankTransaction bankTransaction)
{
BankAccount sender = (from acc in _context.BankAccounts
where acc.IBAN == bankTransaction.SenderIBAN
select acc).First();
BankAccount reciever = (from acc in _context.BankAccounts
where acc.IBAN == bankTransaction.RecieverIBAN
select acc).First();
// Validate the transaction request
if (sender.IsFrozen || sender.Balance < bankTransaction.Amount)
{
return(Conflict());
}
// Move the currency
sender.Balance -= (int)bankTransaction.Amount;
// This is where we would deduct all the fees to fund our space program
reciever.Balance += (int)bankTransaction.Amount;
// Log the transaction
_context.BankTransaction.Add(bankTransaction);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetBankTransaction", new { id = bankTransaction.ID }, bankTransaction));
}
public async Task <IActionResult> PutBankTransaction(uint id, BankTransaction bankTransaction)
{
if (id != bankTransaction.ID)
{
return(BadRequest());
}
_context.Entry(bankTransaction).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!BankTransactionExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public bool IsRuleMatch(ParsedRule rule, BankTransaction bankTransaction)
{
string columnValue = null;
if (rule.IsColumnInExtensions)
{
if (bankTransaction.Extensions != null)
{
var extensions = JToken.Parse(bankTransaction.Extensions);
var column = extensions[rule.Column];
if (column != null)
{
columnValue = column.Value <string>();
}
}
}
else
{
columnValue = GetStaticColumnValue(rule.Column, bankTransaction);
}
if (columnValue != null)
{
if (rule.RuleType == RuleType.Contains)
{
if (columnValue.ToLower().Contains(rule.Value.ToLower()))
{
logger.LogInformation("Found rule for event {0} (Order: {1})", bankTransaction.Title, bankTransaction.Order);
return(true);
}
}
}
return(false);
}
private string GetStaticColumnValue(string columnName, BankTransaction transaction)
{
return(columnName switch
{
"Title" => transaction.Title,
_ => null
});
public long?UpdateExperiencePoints(string workOrderType, BankTransaction trans)
{
Mcmember member = GetMemberbyDcId(trans.Member, trans.Guild);
double xpMod = new WorkOrderController().GetExpModifier(workOrderType);
switch (workOrderType)
{
case "merits":
member.Xp = member.Xp + Convert.ToInt64(trans.Merits * xpMod);
break;
case "credits":
member.Xp = member.Xp + Convert.ToInt64(trans.Amount * xpMod);
break;
default: Console.WriteLine("Currently support xp modifiers are merit and credits");
break;
}
member.Xp = member.Xp + Convert.ToInt64(trans.Amount * xpMod);
MultiBotDb.Mcmember.Update(member);
MultiBotDb.SaveChanges();
return(member.Xp);
}
public void ShowDlg(BankTransaction oBankTransaction, bool IsEdit)
{
//var MaxTran1 = db.BankTransactions
//.Where(a => a.TranDate == db.BankTransactions.Max(x => x.TranDate)).SingleOrDefault();
//if (MaxTran1 != null)
// PrvTotalAmt = MaxTran1.TotalAmt;
//else
// PrvTotalAmt = 0;
_IsEdit = IsEdit;
if (IsEdit)
{
ctlBank.Enabled = false;
ctlAnotherBank.Enabled = false;
ctlCustomer.Enabled = false;
ctlSupplier.Enabled = false;
}
_BankTransaction = oBankTransaction;
PopulateTranTypeCbo();
RefreshValue();
RefreshControl();
this.ShowDialog();
}
public async Task <AllBrokerData> SellStock(BrokerInfo brokerInfo)
{
var playerBrokerAccount = cache.Get <AllBrokerData>(brokerInfo.PlayerName + "_Broker");
if (playerBrokerAccount == null)
{
throw new Exception("No broker account exists for provided player");
}
var playerBankAccount = cache.Get <AllBankRecords>(brokerInfo.PlayerName + "_Bank");
var turn = cache.Get <Clock>(brokerInfo.PlayerName + "_Clock");
var totalPrice = brokerInfo.StockPrice * brokerInfo.Quantity;
var bankTransaction = new BankTransaction();
bankTransaction.PlayerName = playerBankAccount.Accounts.PlayerName;
bankTransaction.Price = totalPrice;
bankTransaction.Transceiver = brokerInfo.Sector;
bankTransaction.Turn = turn.PlayerTurn + 1;
await bankService.Deposit(bankTransaction);
var brokerRecords = new AllBrokerData()
{
};
brokerRecords = playerBrokerAccount;
brokerInfo.Status = Constants.sellStock;
brokerRecords.BrokerInfos.Add(brokerInfo);
cache.Set(brokerInfo.PlayerName + "_Broker", brokerRecords, Constants.cacheTime);
return(brokerRecords);
}
public decimal Deposit(decimal amount)
{
accBal += amount;
BankTransaction tran = new BankTransaction(amount);
tranQueue.Enqueue(tran);
return accBal;
}
public async Task <JArray> RunMessage(int index, CommandContext ctx)
{
var json = readJson();
var msg = json.scheduled[index];
if (index == 3)
{
BankController bank = new BankController();
var trans = new BankTransaction("withdraw", ctx.Member, ctx.Guild, amount: 15000000);
bank.Withdraw(trans);
}
else if (index == 8)
{
SkynetProtocol sk = new SkynetProtocol();
MemberController memCon = new MemberController();
var listUser = ctx.Channel.Users;
foreach (var user in listUser)
{
if (user.IsBot == false)
{
await memCon.StripRank(user);
}
}
}
return(json.scheduled[index].messages);
}
private List <BankTransaction> MapXmlToBankTransactions(string xml)
{
XmlSerializer serializer = new XmlSerializer(typeof(OFX), new XmlRootAttribute("OFX"));
StringReader xmlReader = new StringReader(xml);
var ofxObject = (OFX)serializer.Deserialize(xmlReader);
var bankTransactions = new List <BankTransaction>();
var bank = ofxObject.BANKMSGSRSV1.STMTTRNRS.STMTRS.BANKACCTFROM.BANKID;
var accountNumber = ofxObject.BANKMSGSRSV1.STMTTRNRS.STMTRS.BANKACCTFROM.ACCTID;
var accountType = ofxObject.BANKMSGSRSV1.STMTTRNRS.STMTRS.BANKACCTFROM.ACCTTYPE;
foreach (var transaction in ofxObject.BANKMSGSRSV1.STMTTRNRS.STMTRS.BANKTRANLIST.STMTTRN)
{
var temp = new BankTransaction(
bank.ToString(),
accountNumber.ToString(),
accountType,
this.ConvertDate(transaction.DTPOSTED),
transaction.TRNTYPE,
transaction.TRNAMT,
transaction.MEMO);
bankTransactions.Add(temp);
}
return(bankTransactions);
}
/// <summary>
/// Save new bank transactions, ignore existing ones (no update)
/// </summary>
public int SaveBankTransactionList(string bankAccountNumber, List <BankTransactionDataset> bankTransactions)
{
var count = 0;
var transactions = GetBankTransactionList();
foreach (var bankTrx in bankTransactions)
{
var transaction = transactions.FirstOrDefault(t => t.Id == bankTrx.Id);
if (transaction == null)
{
transaction = new BankTransaction()
{
Id = bankTrx.Id,
BookingDate = bankTrx.BookingDate,
ValueDate = bankTrx.ValueDate,
Value = (decimal)bankTrx.Value,
Text = bankTrx.Text,
BankAccountNumber = bankAccountNumber,
Debtor = bankTrx.Debtor,
Creditor = bankTrx.Creditor,
};
transactions.Add(transaction);
count++;
}
}
Save(transactions, BANK_TRANSACTIONS);
return(count);
}
public void TestImplement()
{
string[] Banks = { "BCP", "INTERBANK", "BBVA", "BCR" };
TransactionFlyWeightFactory Factory = new TransactionFlyWeightFactory();
double TotalDiscount = 0.0d;
for (int Bank = 0; Bank <= 1000; Bank++)
{
string BankCode = Banks[this.GetRandomBankIndex()];
System.Diagnostics.Trace.WriteLine("BANK TRANSACTION :: " + BankCode);
BankTransaction BankTran = (BankTransaction)Factory.GetBankTransactionByBankName(BankCode);
BankTran.TransactionCode = this.GetRandomTransactionCode();
BankTran.Amount = this.GetRandomAmount();
BankTran.DateTime = DateTime.Now;
TotalDiscount += BankTran.GetDiscount();
}
System.Diagnostics.Trace.WriteLine("BANK TRANSACTION DISCOUNT :: " + TotalDiscount);
Assert.AreEqual(Factory.GetBankTransactions().Count, 4);
Assert.AreNotEqual(0.0d, TotalDiscount);
Factory.CleanBankTransactions();
Assert.IsNull(Factory.GetBankTransactions());
}
public void Put(int balance)
{
Balance += balance;
BankTransaction bt = new BankTransaction(balance);
transactions.Enqueue(bt);
}
public List <BankTransaction> DownloadPassbook(string name)
{
List <BankTransaction> passbook = new List <BankTransaction>();
BankTransaction transaction;
using (SqlConnection connection = DBConnection.GetConnection())
{
try
{
connection.Open();
var command = new SqlCommand
("select * from bank_transaction where name = '"
+ name + "'", connection);
var reader = command.ExecuteReader();
_noOfColumns = reader.FieldCount;
while (reader.Read())
{
transaction = new BankTransaction
(Convert.ToString(reader.GetValue(0)), Convert.ToDouble
(reader.GetValue(1)), Convert.ToChar(reader.GetValue(2))
, Convert.ToDateTime(reader.GetValue(3)));
passbook.Add(transaction);
}
}
catch (Exception)
{
}
return(passbook);
}
}
public BankTransaction NewBankTransaction()
{
var newBankTransaction = new BankTransaction
{
Type = BankTransactionType.Spend,
Contact = new Contact {
Name = "ABC Bank"
},
LineItems = new List <LineItem>
{
new LineItem
{
Description = "Yearly Bank Account Fee",
Quantity = 1m,
UnitAmount = 20.00m,
AccountCode = "404"
}
},
BankAccount = new Account {
Id = FindBankAccountGuid()
}
};
return(newBankTransaction);
}
public static void Run([ServiceBusTrigger(QUEUE_NAME, Connection = "ConnectionStringKey")] string myQueueItem, ILogger log)
{
log.LogInformation($"C# ServiceBus queue trigger function processed message: {myQueueItem}");
var bankTransactionRepository = new TableStorageService <BankTransaction>(log, TABLE_STORAGE_CONNECTION_STRING, $"{MY_NAME}BankTransaction");
var bankTransactionStatisticsRepository = new TableStorageService <BankTransactionStatistics>(log, TABLE_STORAGE_CONNECTION_STRING, $"{MY_NAME}BankTransactionStatistics");
var queueMessage = JsonConvert.DeserializeObject <QueueMessage>(myQueueItem);
var transaction = new BankTransaction(queueMessage);
bankTransactionRepository.InsertOrUpdateEntry(transaction);
var transactions = bankTransactionRepository.GetByPartitionId(transaction.PartitionKey);
var totalAmmount = transactions.Sum(t => t.Ammount);
var existingBankTransactionStatistics = bankTransactionStatisticsRepository.GetByPartitionId(transaction.PartitionKey).FirstOrDefault();
if (existingBankTransactionStatistics != null)
{
existingBankTransactionStatistics.Ammount = totalAmmount;
}
else
{
existingBankTransactionStatistics = new BankTransactionStatistics(Guid.NewGuid().ToString(), transaction.PartitionKey)
{
Ammount = totalAmmount
};
}
bankTransactionStatisticsRepository.InsertOrUpdateEntry(existingBankTransactionStatistics);
}
/// <summary>
/// Method to fill StatementDetails object
/// </summary>
/// <param name="statementDetailsNodes">StatementDetails XML Nodes</param>
/// <param name="account">Account object filled</param>
/// <param name="bankTransaction">BankTransaction object filled</param>
/// <returns>StatementDetails object filled</returns>
private StatementDatails FillStatementDetails(Account account, BankTransaction bankTransaction, Balance balance, XmlDocument xmlDoc)
{
var xPath = "OFX/BANKMSGSRSV1/STMTTRNRS/STMTRS";
var statementDetailsNodes = xmlDoc.SelectNodes(xPath);
var statementDatails = new StatementDatails();
foreach (XmlNode node in statementDetailsNodes)
{
for (var i = 0; i < node.ChildNodes.Count; i++)
{
switch (node.ChildNodes[i].Name)
{
case "CURDEF":
statementDatails.Currency = node.ChildNodes[i].InnerText;
break;
}
}
}
statementDatails.Account = account;
statementDatails.BankTransaction = bankTransaction;
statementDatails.Balance = balance;
return(statementDatails);
}
public ActionResult Edit(BankTransaction model)
{
var success = false;
try
{
var transaction = paymentService.GetBankTransaction(model.ID);
if (transaction != null)
{
paymentService.UpdateTransaction(model.Amount, model.ID, model.PaymentDate, model.PaymentMethod, model.Notes, model.Reference);
success = true;
}
}
catch (Exception ex)
{
success = false;
loggingService.LogException(ex);
}
SetFeedbackMessage(success,
"Payment has been amended.",
"There has been an error whilst amending the payment.");
return(RedirectToSamePage());
}
private static List <BankTransaction> ConvertToTransactions(IEnumerable <LeumiTransactionResponse> transactions)
{
var result = new List <BankTransaction>();
foreach (var transaction in transactions)
{
var newTransaction = new BankTransaction
{
Id = (Convert.ToInt64(transaction.SupplierId) + Math.Round(transaction.Amount) +
Math.Round(transaction.CurrentBalance)).ToString(CultureInfo.InvariantCulture),
Type = transaction.Type,
IsFee = false,
PurchaseDate = transaction.PurchaseDate,
PaymentDate = transaction.PaymentDate,
Description = transaction.Description,
ProviderName = ProviderName,
Amount = transaction.Amount,
CurrentBalance = transaction.CurrentBalance,
SupplierId = transaction.SupplierId
};
result.Add(newTransaction);
}
return(result);
}
/// <summary>
/// Get Bank transactions from xml string
/// </summary>
public IEnumerable <BankTransaction> ExtractBankTransactionsFromXml(string xml)
{
List <BankTransaction> txnList = new List <BankTransaction>();
try
{
XDocument xdoc = null;
xdoc = XDocument.Parse(xml);
IEnumerable <XElement> elementList = from el in xdoc.Elements().Elements()
select el;
CultureInfo provider = CultureInfo.InvariantCulture;
foreach (var item in elementList)
{
if (item.Name == "STMTTRN")
{
BankTransaction newTxn = new BankTransaction
{
FITID = item.Element("FITID").Value,
Amount = Convert.ToDecimal(item.Element("TRNAMT").Value),
Date = DateTime.ParseExact(item.Element("DTPOSTED").Value
, "yyyyMMddhhmmss", provider),
Merchant = item.Element("NAME").Value
};
txnList.Add(newTxn);
}
}
return(txnList);
}
catch (Exception ex)
{
throw new FieldAccessException("Badly formatted XML string", ex);
}
}
public static void SetDates(DatePicker date_month_from, DatePicker date_month_to)
{
Tuple <DateTime, DateTime> dates = BankTransaction.GetDates("Home");
if (dates != null)
{
date_month_to.SelectedDate = new DateTime(dates.Item2.Year, dates.Item2.Month, 1).AddMonths(1).AddDays(-1);
date_month_to.DisplayDate = new DateTime(dates.Item2.Year, dates.Item2.Month, 1).AddMonths(1).AddDays(-1);
if (date_month_from != null)
{
date_month_from.SelectedDate = new DateTime(dates.Item2.Year, dates.Item2.Month, 1).AddMonths(-11);
date_month_from.DisplayDate = new DateTime(dates.Item2.Year, dates.Item2.Month, 1).AddMonths(-11);
}
}
else
{
date_month_to.SelectedDate = new DateTime(DateTime.Today.Year, DateTime.Today.Month, 1).AddDays(-1);
date_month_to.DisplayDate = new DateTime(DateTime.Today.Year, DateTime.Today.Month, 1).AddDays(-1);
if (date_month_from != null)
{
date_month_from.SelectedDate = new DateTime(DateTime.Today.Year, DateTime.Today.Month, 1).AddMonths(-11).AddDays(-1);
date_month_from.DisplayDate = new DateTime(DateTime.Today.Year, DateTime.Today.Month, 1).AddMonths(-11).AddDays(-1);
}
}
}
public int CreateTransaction(beTransaction transEntity)
{
using (var scope = new TransactionScope())
{
var transaction = new BankTransaction
{
Id = new int(),
AccountId = transEntity.AccountId,
Amount = transEntity.Amount,
CategoryId = transEntity.CategoryId,
Date = transEntity.Date,
Description = transEntity.Description,
IsSplitTransaction = transEntity.IsSplitTransaction,
Note = transEntity.Note,
ParentId = transEntity.ParentId,
Payee = transEntity.Payee,
ReferenceId = transEntity.ReferenceId,
TxSource = transEntity.TxSource,
Type = transEntity.Type,
UserId = transEntity.UserId
};
_unitOfWork.TransactionRepository.Insert(transaction);
_unitOfWork.Save();
scope.Complete();
return(transaction.Id);
}
}
public void UpdatePayment(Payment payment, BankTransaction transaction)
{
if (payment == null)
{
throw new ArgumentNullException(nameof(payment));
}
if (transaction == null)
{
throw new ArgumentNullException(nameof(transaction));
}
switch (transaction.Status)
{
case BankTransactionStatus.Failed:
payment.Reject(transaction.Id);
break;
case BankTransactionStatus.Success:
payment.Approve(transaction.Id);
break;
default:
throw new UnknownBankStatusException(transaction.Status.ToString(), transaction.Id, transaction.PaymentId);
}
}
/* <TextBox Name="sendRecipientIBAN" Grid.Row="0" Grid.Column="1" Text="" Width="250" FontSize="13" HorizontalAlignment="Left" Margin="10,0,0,0" VerticalAlignment="Center"/>
* <TextBox Name="sendRecipientName" Grid.Row="1" Grid.Column="1" Text="" Width="250" FontSize="13" HorizontalAlignment="Left" Margin="10,0,0,0" VerticalAlignment="Center"/>
* <TextBox Name="sendAmount" Grid.Row="2" Grid.Column="1" Text="" Width="250" FontSize="13" HorizontalAlignment="Left" Margin="10,0,0,0" VerticalAlignment="Center"/>
* <TextBox Name="sendMessage"*/
public static async Task <string> SendTransactionAsync(BankAccount senderAccount, string recipientIBAN, string recipientName, uint amount, string message)
{
if (senderAccount.Balance < amount)
{
return("Insufficient funds");
}
if (!await HttpMgr.Instance.DoesAccountExistsAsync(recipientIBAN))
{
return("Recipient account does not exists");
}
// Build the transaction
BankTransaction transaction = new BankTransaction
{
Amount = amount,
Message = message,
ReceiverName = recipientName,
RecieverIBAN = recipientIBAN,
SenderIBAN = senderAccount.CombineIBAN,
SenderName = CustomerManager.Instance.LoggedInCustomer.FullName,
Date = DateTime.Now
};
// Send it to the API
return(await HttpMgr.Instance.PostTransactionAsync(transaction));
}
public void CheckingServiceFeeTransaction(double TransactionAmount, DateTime TransactionDateTime, string BankName)
{
TransactionDateTime = DateTime.Now;
var chargeFee = new Transaction(TransactionAmount, TransactionDateTime, BankName);
BankTransaction.Enqueue(chargeFee);
}
public bool ConfirmPayContractByCard(Guid subscriptionId, string confirmationCode)
{
var paymentConfirmation = _unitOfWork.GetRepository <PaymentConfirmationCode>()
.GetSingle(x => x.SubscriptionId == subscriptionId);
var subscription = _unitOfWork.GetRepository <Subscription>().GetSingle(x => x.Id == subscriptionId);
//var banckResult = BanckAPI.ApproveTranzaction(paymentConfirmationCode.CallBackCode, confirmationCode);
var bankTransaction = new BankTransaction()
{
Date = DateTime.UtcNow,
From = paymentConfirmation.CardNumber,
Id = Guid.NewGuid(),
Sum = subscription.Price,
To = "CompanyAccount",
Type = BankTransactionType.Payment,
UserId = subscription.SubscriberId
};
_unitOfWork.GetRepository <BankTransaction>().Add(bankTransaction);
_unitOfWork.Save();
return(true);
}
public bool Withdraw(decimal amount)
{
bool sufficientFunds = accBal >= amount;
if (sufficientFunds) {
accBal -= amount;
BankTransaction tran = new BankTransaction(-amount);
tranQueue.Enqueue(tran);
}
return sufficientFunds;
}
public void AddTransaction(BankTransaction transaction)
{
Transactions.Add(transaction);
}
