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); }