public TransactionHistory Update(TransactionHistory item) { //The tsxhistory state currently modified is saved to the DB Context.Entry(item).State = EntityState.Modified; Context.SaveChanges(); return(item); }
public void RutTien() { Console.WriteLine("Nhập số tiền cần rút: "); decimal amount = Utility.GetUnsignedDecimalNumber(); // lấy thông tin tài khoản mới nhất trước khi kiểm tra số dư. MainThread.currentLoggedInAccount = model.GetAccountByUsername(MainThread.currentLoggedInAccount.UserName); if (amount > MainThread.currentLoggedInAccount.Balance) { Console.WriteLine("Không đủ tiền trong tài khoản."); return; } Console.WriteLine("Nhập nội dung giao dịch: "); var content = Console.ReadLine(); var transactionHistory = new TransactionHistory() { Id = Guid.NewGuid().ToString(), Type = TransactionHistory.TransactionType.WITHDRAW, Amount = amount, Content = content, SenderAccountNumber = MainThread.currentLoggedInAccount.AccountNumber, ReceiverAccountNumber = MainThread.currentLoggedInAccount.AccountNumber }; if (model.UpdateBalance(MainThread.currentLoggedInAccount, transactionHistory)) { Console.WriteLine("Giao dịch thành công."); } }
public void Deposit(double amount) { Transac = new Transaction(); Balance += amount; Transac.MakeTransaction(true, amount, Balance); TransactionHistory.Add(Transac); }
public async Task <IActionResult> PutTransactionHistory(int id, TransactionHistory transactionHistory) { if (id != transactionHistory.Id) { return(BadRequest()); } _context.Entry(transactionHistory).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!TransactionHistoryExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public static decimal RetriveSomeMoney(string cardNumber, string cardPin, decimal amount) { ATMEntities dbATM = new ATMEntities(); var transOption = new TransactionOptions(); transOption.IsolationLevel = IsolationLevel.RepeatableRead; var scope = new TransactionScope(TransactionScopeOption.RequiresNew, transOption); using (scope) { foreach (var account in dbATM.CardAccounts) { if ((account.CardNumber == cardNumber) && (account.CardPIN == cardPin) && (account.CardCash > amount)) { account.CardCash -= amount; var log = new TransactionHistory() { CardNumber = cardNumber, TransactionDate = DateTime.Now, Amount = amount }; dbATM.TransactionHistories.Add(log); dbATM.SaveChanges(); scope.Complete(); return(amount); } } } return(-1); }
public async Task <IActionResult> PostTransactionHistory([FromBody] TransactionHistory transactionHistory) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } _context.TransactionHistory.Add(transactionHistory); try { await _context.SaveChangesAsync(); } catch (DbUpdateException) { if (TransactionHistoryExists(transactionHistory.Id)) { return(new StatusCodeResult(StatusCodes.Status409Conflict)); } else { throw; } } return(CreatedAtAction("GetTransactionHistory", new { id = transactionHistory.Id }, transactionHistory)); }
public async Task <TransactionStatus> withdraw([FromBody] dynamic model /*int AccountId, int amount*/) { HttpClient client = obj.AccountDetails(); HttpResponseMessage response = client.GetAsync("api/Account/getAccount/?AccountId=" + model.AccountId).Result; var result = response.Content.ReadAsStringAsync().Result; Account acc = JsonConvert.DeserializeObject <Account>(result); HttpResponseMessage response1 = client.PostAsJsonAsync("api/Account/withdraw", new { AccountID = Convert.ToInt32(model.AccountId), Amount = Convert.ToInt32(model.amount) }).Result; var result1 = response1.Content.ReadAsStringAsync().Result; TransactionStatus st = JsonConvert.DeserializeObject <TransactionStatus>(result1); cnt = cnt + 256; TransactionHistory history = new TransactionHistory() { TransactionId = cnt, AccountId = Convert.ToInt32(model.AccountId), message = st.message, source_balance = st.source_balance, destination_balance = st.destination_balance, DateOfTransaction = DateTime.Now, CustomerId = acc.CustomerId }; _provider.AddToTransactionHistory(history); return(st); }
//total,change public void InsertDataToTransaction( IDbConnection database, TransactionHistory transaction) { using (SqlCommand command = new SqlCommand(Constants.CreateTransactionRecord, new SqlConnection(database.ConnectionString))) { try { command.Connection.Open(); command.CommandType = CommandType.StoredProcedure; command.Parameters.Add("@item", SqlDbType.NVarChar, 30).Value = transaction.itemName; command.Parameters.Add("@qty", SqlDbType.Int).Value = transaction.qty; command.Parameters.Add("@amount", SqlDbType.Decimal, 18).Value = transaction.amount; command.Parameters.Add("@total", SqlDbType.Decimal, 18).Value = transaction.total; command.Parameters.Add("@cash", SqlDbType.Decimal, 18).Value = transaction.cash; command.Parameters.Add("@change", SqlDbType.Decimal, 18).Value = transaction.change; command.Parameters.Add("@tax", SqlDbType.Decimal, 4).Value = transaction.tax; command.Parameters.Add("@transaction_date", SqlDbType.DateTime).Value = transaction.transDate; command.Parameters.Add("@establishment_id", SqlDbType.Int).Value = transaction.establishment_Id; command.ExecuteNonQuery(); } catch (FormatException formatException) { MessageBox.Show(formatException.Message, "Record Creation Failed!"); } } }
public async Task CloseOrderAsync(string accountId, string orderId) { var account = await _accountInfoRepository.GetByIdAsync(accountId); var activeOrder = await _marketOrderRepository.GetAsync(accountId, orderId); var assetPair = await _dictionaryProxy.GetAssetPairByIdAsync(activeOrder.AssetPairId); var quote = await _assetPairQuoteRepository.GetByIdAsync(activeOrder.AssetPairId); var transactionHistory = new TransactionHistory { AccountId = activeOrder.ClientId, AssetPairId = activeOrder.AssetPairId, CompletedAt = DateTime.UtcNow, TransactionId = activeOrder.Id, Price = activeOrder.OrderAction == OrderAction.Buy ? quote.Ask : quote.Bid }; var profitLoss = await _orderCalculator.CalculateProfitLossAsync(activeOrder.Price, transactionHistory.Price, activeOrder.Volume, assetPair, account.BaseAssetId); transactionHistory.ProfitLoss = profitLoss; await _transactionHistoryRepository.AddAsync(transactionHistory); await _marketOrderRepository.DeleteAsync(accountId, orderId); account.Balance += profitLoss; await _accountInfoRepository.UpdateAsync(account); await _matchingEngineEventSubscriber.AccountUpdatedAsync(accountId); }
public async Task TransactionService_RecurringMonthlyBillAsync_Test() { try { var renterId = Guid.Parse("2AC48057-8D5D-4C5A-8B1F-05464C62CEED"); var payment = 4500; using (var db = new DatabaseContext(dbContextOpt.Options)) { var lastTransaction = db.Transactions .Where(t => t.RenterId == renterId) .OrderByDescending(t => t.DatePaid) .First(); var monthlyRent = await db.RoomsRented .Join( db.Rooms, roomRented => roomRented.RoomId, room => room.Id, (roomRented, room) => new { roomRented, room } ) .Join( db.RoomTypes, room => room.room.RoomTypeId, roomType => roomType.Id, (room, roomType) => new { room, roomType.Price } ) .Where(renter => renter.room.roomRented.RenterId == renterId) .Select(room => room.Price) .SingleOrDefaultAsync(); Assert.IsNotNull(monthlyRent); decimal amountDue = lastTransaction.Balance + monthlyRent; decimal balance = amountDue - payment; var transaction = new TransactionHistory { Id = Guid.NewGuid(), DatePaid = DateTime.Now, AmountDue = amountDue, AmountPaid = payment, PaymentFor = "Rental", Balance = balance, NextDateDue = lastTransaction.NextDateDue.AddMonths(1), RenterId = renterId }; db.Transactions.Add(transaction); var saveTransaction = await db.SaveChangesAsync(); Assert.IsTrue(saveTransaction == 1, "Error saving transaction."); } } catch (Exception ex) { logService.Log("Recurring Monthly Billing", ex.InnerException.Message, ex.Message, ex.StackTrace); Assert.Fail(); } }
public ActionResult ByMonth(int month, int year) { var logged = (Account)Session["logged"]; if (logged.Customers.Cs_status == "0") { return(RedirectToAction("Signout", "Home")); } var isValid = db.TransactionHistory.ToList().Where(p => r.stringToDate(p.tran_time).Month == month && r.stringToDate(p.tran_time).Year == year && (p.ReceiveAccount == logged.Customers.acc_num || p.SendAccount == logged.Customers.acc_num)).ToList(); TransactionHistory tran = new TransactionHistory() { Message = "Print invoice fee", SendAccount = logged.Customers.acc_num, ReceiveAccount = "013639335", Amount = 10000, tran_time = DateTime.Now.ToString("MM/dd/yyyy HH:mm:ss"), fee = 0, Code = "T", Status = "S", Bank_id = 2 }; db.TransactionHistory.Add(tran); db.Customers.Find(logged.Customers.Id).balance -= 10000; db.SaveChanges(); //Phi in sao ke 10000/1 thang,20k/1 quy' InvoicePrepare invoice = new InvoicePrepare(); byte[] abytes = invoice.Prepare(isValid, logged.Customers.acc_num); return(File(abytes, "application/pdf")); }
public async Task GetTransaction_ShouldReturnTransactionHistory_WhenFoundById() { var transactionId = 29292; var expectedTransactionHistory = new TransactionHistory { CardNumber = "123412******1234", CardHolderName = "K Li", Amount = 999.8m, Currency = "GBP", Success = true, CreatedDate = new DateTime(2021, 5, 17, 22, 17, 00) }; _mockTransactionService.Setup(x => x.GetTransactionHistoryById(transactionId)).ReturnsAsync(expectedTransactionHistory); var actual = (OkObjectResult)await _transactionController.Get(transactionId); var actualResponse = actual.Value as TransactionHistoryResponse; Assert.Equal(expectedTransactionHistory.CardNumber, actualResponse.CardNumber); Assert.Equal(expectedTransactionHistory.CardHolderName, actualResponse.CardHolderName); Assert.Equal(expectedTransactionHistory.Amount, actualResponse.Amount); Assert.Equal(expectedTransactionHistory.Currency, actualResponse.Currency); Assert.Equal(expectedTransactionHistory.Success, actualResponse.Success); Assert.Equal(expectedTransactionHistory.CreatedDate, actualResponse.CreatedDate); }
///<summary> /// Returns a Typed TransactionHistory Entity with mock values. ///</summary> static public TransactionHistory CreateMockInstance_Generated(TransactionManager tm) { TransactionHistory mock = new TransactionHistory(); mock.ReferenceOrderId = TestUtility.Instance.RandomNumber(); mock.ReferenceOrderLineId = TestUtility.Instance.RandomNumber(); mock.TransactionDate = TestUtility.Instance.RandomDateTime(); mock.TransactionType = TestUtility.Instance.RandomString(1, false);; mock.Quantity = TestUtility.Instance.RandomNumber(); mock.ActualCost = TestUtility.Instance.RandomShort(); mock.ModifiedDate = TestUtility.Instance.RandomDateTime(); //OneToOneRelationship Product mockProductByProductId = ProductTest.CreateMockInstance(tm); DataRepository.ProductProvider.Insert(tm, mockProductByProductId); mock.ProductId = mockProductByProductId.ProductId; // create a temporary collection and add the item to it TList <TransactionHistory> tempMockCollection = new TList <TransactionHistory>(); tempMockCollection.Add(mock); tempMockCollection.Remove(mock); return((TransactionHistory)mock); }
/// <summary> /// Test Find using the Query class /// </summary> private void Step_30_TestFindByQuery_Generated() { using (TransactionManager tm = CreateTransaction()) { //Insert Mock Instance TransactionHistory mock = CreateMockInstance(tm); bool result = DataRepository.TransactionHistoryProvider.Insert(tm, mock); Assert.IsTrue(result, "Could Not Test FindByQuery, Insert Failed"); TransactionHistoryQuery query = new TransactionHistoryQuery(); query.AppendEquals(TransactionHistoryColumn.TransactionId, mock.TransactionId.ToString()); query.AppendEquals(TransactionHistoryColumn.ProductId, mock.ProductId.ToString()); query.AppendEquals(TransactionHistoryColumn.ReferenceOrderId, mock.ReferenceOrderId.ToString()); query.AppendEquals(TransactionHistoryColumn.ReferenceOrderLineId, mock.ReferenceOrderLineId.ToString()); query.AppendEquals(TransactionHistoryColumn.TransactionDate, mock.TransactionDate.ToString()); query.AppendEquals(TransactionHistoryColumn.TransactionType, mock.TransactionType.ToString()); query.AppendEquals(TransactionHistoryColumn.Quantity, mock.Quantity.ToString()); query.AppendEquals(TransactionHistoryColumn.ActualCost, mock.ActualCost.ToString()); query.AppendEquals(TransactionHistoryColumn.ModifiedDate, mock.ModifiedDate.ToString()); TList <TransactionHistory> results = DataRepository.TransactionHistoryProvider.Find(tm, query); Assert.IsTrue(results.Count == 1, "Find is not working correctly. Failed to find the mock instance"); } }
/// <summary> /// Deep load all TransactionHistory children. /// </summary> private void Step_03_DeepLoad_Generated() { using (TransactionManager tm = CreateTransaction()) { int count = -1; mock = CreateMockInstance(tm); mockCollection = DataRepository.TransactionHistoryProvider.GetPaged(tm, 0, 10, out count); DataRepository.TransactionHistoryProvider.DeepLoading += new EntityProviderBaseCore <TransactionHistory, TransactionHistoryKey> .DeepLoadingEventHandler( delegate(object sender, DeepSessionEventArgs e) { if (e.DeepSession.Count > 3) { e.Cancel = true; } } ); if (mockCollection.Count > 0) { DataRepository.TransactionHistoryProvider.DeepLoad(tm, mockCollection[0]); System.Console.WriteLine("TransactionHistory instance correctly deep loaded at 1 level."); mockCollection.Add(mock); // DataRepository.TransactionHistoryProvider.DeepSave(tm, mockCollection); } //normally one would commit here //tm.Commit(); //IDisposable will Rollback Transaction since it's left uncommitted } }
public async Task GetTransactionHistoryById_ShouldReturnTransactionHistory_WhenTransactionFound() { var transactionId = 31215; var expectedCardNumber = "123412******1234"; var expectedTransactionHistory = new TransactionHistory { CardNumber = "1234123412341234", CardHolderName = "K Li", Amount = 999.8m, Currency = "GBP", Success = true, CreatedDate = new DateTime(2021, 5, 17, 22, 17, 00) }; _mockTransactionRepository.Setup(x => x.GetTransactionHistoryById(transactionId)) .ReturnsAsync(expectedTransactionHistory); _mockCardService.Setup(x => x.MaskCardNumber(expectedTransactionHistory.CardNumber)) .Returns(expectedCardNumber); var actual = await _transactionService.GetTransactionHistoryById(transactionId); Assert.Equal(expectedCardNumber, actual.CardNumber); Assert.Equal(expectedTransactionHistory.CardHolderName, actual.CardHolderName); Assert.Equal(expectedTransactionHistory.Amount, actual.Amount); Assert.Equal(expectedTransactionHistory.Currency, actual.Currency); Assert.Equal(expectedTransactionHistory.Success, actual.Success); Assert.Equal(expectedTransactionHistory.CreatedDate, actual.CreatedDate); }
private void RecordTransactionHistory(ActivityHistory activityHistory) { //if (activityHistory == null) //{ // activityHistory = activityHistoryRepository.GetLastActivityHistory( // RequestHeader.Id, // CurrentActivity().ActivityName, // WorkflowInstance.loginName // ); //} string jsonData = GetJsonDataInstance(); var transactionHistory = new TransactionHistory() { ObjectType = "PROCESS_REQUEST", ObjectName = (activityHistory != null? "[BPMDATA].[APPROVAL_COMMENT]":"[BPMDATA].[REQUEST_HEADER]"), ObjectId = (activityHistory != null? activityHistory.Id:RequestHeader.Id), JsonData = jsonData, CreatedDate = DateTime.Now, CreatedBy = WorkflowInstance.loginName }; _transactionHistoryRepository.Add(transactionHistory); unitOfWork.commit(); }
public ActionResult TransferFund([Bind(Include = "CustomerId, MoneyTransfered, TransferType")] TransactionHistory transactiondetail) { try { // TODO: Add insert logic here var currentUser = dbcontext.AspNetUsers.FirstOrDefault(u => u.Email == User.Identity.Name); // transactiondetail.Customer = ; transactiondetail.Customer = dbcontext.Customers.FirstOrDefault(c => c.UserId == currentUser.Id); transactiondetail.CustomerId = transactiondetail.Customer.Id; dbcontext.TransactionHistories.Add(transactiondetail); if (transactiondetail.TransferType == 1) { transactiondetail.Customer.AccountBalance -= transactiondetail.MoneyTransfered; } else { transactiondetail.Customer.AccountBalance += transactiondetail.MoneyTransfered; } dbcontext.SaveChanges(); return(RedirectToAction("Index")); } catch (Exception ex) { return(View()); } }
private void AddProgressTransaction(Progress progress, IEnumerable <Payment> payments, List <Payment> alreadyIdentified, DateTime createdDate, DateTime referenceDate, string employeeAddress, string companyAddress, string employeeTransaction, string companyTransaction, int?employeeBlockNumber, int?companyBlockNumber, double?employeeToken, double?companyToken) { TransactionHistory transaction = new TransactionHistory(); transaction.CreationDate = createdDate.Ticks; transaction.PaymentDate = referenceDate.ToString("yyyy - MM - dd"); transaction.CompanyBlockNumber = companyBlockNumber; transaction.EmployeeBlockNumber = employeeBlockNumber; transaction.EmployeeToken = employeeToken; transaction.CompanyToken = companyToken; if (!string.IsNullOrEmpty(employeeTransaction) && !string.IsNullOrEmpty(companyTransaction)) { transaction.EmployeeTransactionHash = employeeTransaction; transaction.CompanyTransactionHash = companyTransaction; } else if (!string.IsNullOrEmpty(employeeTransaction)) { transaction.EmployeeTransactionHash = employeeTransaction; transaction.CompanyTransactionHash = FindPaymentThatMatchWith(payments, alreadyIdentified, createdDate, employeeAddress, companyAddress)?.TransactionHash; } else { transaction.CompanyTransactionHash = companyTransaction; transaction.EmployeeTransactionHash = FindPaymentThatMatchWith(payments, alreadyIdentified, createdDate, companyAddress, employeeAddress)?.TransactionHash; } progress.TransactionHistory.Add(transaction); }
async Task ExecuteLoadTransactionHistoryCommand() { if (IsBusy) { return; } IsBusy = true; try { TransactionHistory.Clear(); var transactions = await UserController.GetTransactionHistory(); foreach (var trans in transactions) { TransactionHistory.Add(trans); } } catch (Exception ex) { Debug.WriteLine(ex); } finally { IsBusy = false; } }
private static void WithdrawMoney(string pin, string cardNumber, decimal money, ATMSystemContext dbContext) { try { var account = dbContext.CardAccounts.Where(a => a.CardPIN == pin && a.CardNumber == cardNumber && a.CardCash >= money); account.First().CardCash -= money; Console.WriteLine("Transaction successfull."); var transactionLog = new TransactionHistory() { CardNumber = cardNumber, Amount = money, TransactionDate = DateTime.Now, }; dbContext.TransactionHistories.Add(transactionLog); dbContext.SaveChanges(); } catch (Exception) { Console.WriteLine("Operation Failed."); } }
public async Task <TransactionHistoryDto> Handle(GetTransactionHistoryQuery request, CancellationToken cancellationToken) { return(await Task.Run(() => { List <TransactionHistory> transactionHistories = new List <TransactionHistory>(); var account = _unitOfWork.Account.GetFirstOrDefault(a => a.AccountNumber == request.AccountNumber); var transactions = _unitOfWork.Transaction.GetAll(t => t.AccountId == account.AccountId).OrderByDescending(a => a.TransactionDate).ToList(); foreach (var trans in transactions) { var transactionHistory = new TransactionHistory(); transactionHistory.TransactionType = trans.TransactionType; transactionHistory.Amount = trans.Amount; transactionHistory.RemainingBalance = trans.RemainingBalance; transactionHistory.TransactionDate = trans.TransactionDate; transactionHistory.Remarks = trans.Remarks; transactionHistories.Add(transactionHistory); } var transactionHistoryDto = new TransactionHistoryDto { ClientId = account.ClientId, AccountNumber = account.AccountNumber, Balance = account.Balance, Transactions = transactionHistories }; return transactionHistoryDto; })); }
public async Task <ActionResult <TransactionHistory> > createTransactionHistory(TransactionHistoryDTO dto) { TransactionHistory transactionHistory = new TransactionHistory(); //truyền xuống dto có 4 field: postid, giver, receiver, transactiondate transactionHistory.PostId = dto.PostId; transactionHistory.Giver = dto.Giver; transactionHistory.Receiver = dto.Receiver; transactionHistory.TransactionDate = DateTime.Now; TblUsersHavingPosts usersHavingPosts = _context.TblUsersHavingPosts.FromSqlRaw("select * from TblUsersHavingPosts where " + "Username = {0} and PostId = {1}", dto.Receiver, dto.PostId).First(); //tìm bài post của freelancer đã hoàn thành usersHavingPosts.Status = "finished"; //set status = finished _context.Entry(usersHavingPosts).State = EntityState.Modified; TblPosts post = _context.TblPosts.FromSqlRaw("select * from TblPosts where " + "Id = {0}", dto.PostId).First(); //tìm bài post trong TblPosts post.IsPublic = false; //ko public bài post nữa _context.Entry(post).State = EntityState.Modified; Int64 postAmount = _context.TblPosts.Find(dto.PostId).Amount; //lấy ra amount của bài post transactionHistory.Amount = postAmount; //lưu vào transaction history _context.TransactionHistory.Add(transactionHistory); //add transaction dto vào table TransactionHistory TblUsers company = _context.TblUsers.Find(dto.Giver); //tìm ra company company.Amount -= postAmount; //lấy amount hiện tại của company - amount của bài post đã finished _context.Entry(company).State = EntityState.Modified; TblUsers freelancer = _context.TblUsers.Find(dto.Receiver); //tìm ra freelancer freelancer.Amount += postAmount; //lấy amount hiện tại của freelancer + amount của bài post đã finished _context.Entry(freelancer).State = EntityState.Modified; await _context.SaveChangesAsync(); return(transactionHistory); }
/// <summary> /// For Next Iteration: /// total is not included bec the stored proc will be the one to populate this field. pending /// change is not included bec the stored proc will be the one to populate this field. pending /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void CreateRecord_Click(object sender, RoutedEventArgs e) { try { _utility.TransactionHistoryCreate ( Constants.SqlServerClient.ToString(), Constants.SqlServerConnection, transaction = new TransactionHistory { itemName = itemTxt.Text, qty = qtyTxt.Text, amount = amountTxt.Text, total = totalTxt.Text, cash = cashTxt.Text, change = changeTxt.Text, tax = taxTxt.Text, transDate = date.Value.ToShortDateString(), establishment_Id = establishment_Id } ); this.CustomRefresh(); this.Clear(); } catch (System.InvalidOperationException) { MessageBox.Show("The fields are empty" + ". Please input values to the fields.", "Record Creation Failed!"); } }
public async Task <IActionResult> PutWallet(string id, WalletViewModel wallet) { if (id != wallet.Id) { return(BadRequest()); } try { var currentWallet = await _context.Wallets.Where(x => x.Id == id).FirstOrDefaultAsync(); var user = await _context.AppUsers.Where(x => x.Id.ToString() == currentWallet.UserId).FirstOrDefaultAsync(); var newCoin = wallet.Coin - currentWallet.Coin; var newPromotionCoin = wallet.PromotionCoin - currentWallet.PendingCoin; var transactionHistory = new TransactionHistory { Id = Guid.NewGuid().ToString(), UserId = wallet.UserId, BillStatus = BillStatus.Completed, Coin = Math.Abs(newCoin), DateCreated = DateTime.Now, Status = Status.Active, TransactionHistoryType = (newCoin > 0) ? TransactionHistoryType.PayIn : TransactionHistoryType.Withdraw, }; string notifyTransaction = " đã nạp "; if (transactionHistory.TransactionHistoryType == TransactionHistoryType.Withdraw) { notifyTransaction = " đã rút "; } transactionHistory.Content = "Tài khoản " + user.UserName + notifyTransaction + newCoin + " vào lúc " + transactionHistory.DateCreated.ToString("dd/MM/yyyy hh:mm:ss tt"); _context.TransactionHistories.Add(transactionHistory); currentWallet.PromotionCoin = wallet.PromotionCoin; currentWallet.Coin = wallet.Coin; _context.Wallets.Update(currentWallet); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!WalletExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public TransactionResponse RecordTransaction(int bookingId, int accountId) { //this method allows the closed booking to be recorded as a //transaction using the users payment method //bring in the users account, payment method and booking var closedBooking = BookingRepository.Find(bookingId); var paymentMethod = PaymentMethodRepository.Find(closedBooking.AccountID); var userAccount = UserRepository.Find(closedBooking.AccountID); //error check to make sure a payment method has been supplied if (paymentMethod == null) { return new TransactionResponse { Message = "Payment method for account " + $"{closedBooking.AccountID} does not exist.", Success = false } } ; //error check to make sure user does exist if (userAccount == null) { return new TransactionResponse { Message = $"The user with ID " + $"{closedBooking.AccountID} does not exist.", Success = false } } ; //bundle a new transaction with neccessary values and add tsx var tsx = new TransactionHistory { BookingID = bookingId, TransactionDate = DateTime.Now, TransactionStatus = Constants.TransactionClearedStatus, PaymentMethod = paymentMethod.CardType, PaymentAmount = closedBooking.AmountBilled }; TransactionHistoryRepository.Add(tsx); //return a successful transaction return(new TransactionResponse { Success = true, Message = "Transaction history has been " + $"recorded for booking {bookingId}" }); }
public TransactionHistory Update(TransactionHistory item) { //update the TransactionHistory with new entry TransactionHistories.RemoveAll(x => x.TransactionID == item.TransactionID); TransactionHistories.Add(item); return(item); }
public TransactionHistory Add(TransactionHistory item) { //Function to add a new tsxhistory item to the DB and save changes var transaction = Context.TransactionHistories.Add(item); Context.SaveChanges(); return(transaction); }
///<summary> /// Update the Typed TransactionHistory Entity with modified mock values. ///</summary> static public void UpdateMockInstance(TransactionManager tm, TransactionHistory mock) { TransactionHistoryTest.UpdateMockInstance_Generated(tm, mock); // make any alterations necessary // (i.e. for DB check constraints, special test cases, etc.) SetSpecialTestData(mock); }
public async Task <Result> SendMoney(WalletDto walletToUpdate) { await using var transaction = await _context.Database.BeginTransactionAsync(); try { var beneficiaryWallet = await _context.Wallets .Where(x => x.CurrencyId == walletToUpdate.CurrencyId) .FirstOrDefaultAsync(x => x.UserId == walletToUpdate.UserId && !x.Deleted); var currentUserWallet = await _context.Wallets .Where(x => x.CurrencyId == walletToUpdate.CurrencyId) .FirstOrDefaultAsync(x => x.UserId == _currentUserService.UserId.Value && !x.Deleted); if (beneficiaryWallet == null) { return(Result.Failure(new List <string> { "No valid beneficiary wallet found" })); } if (currentUserWallet.TotalAmount >= walletToUpdate.TotalAmount) { currentUserWallet.TotalAmount -= walletToUpdate.TotalAmount; beneficiaryWallet.TotalAmount += walletToUpdate.TotalAmount; var entity = new TransactionHistory { Amount = walletToUpdate.TotalAmount, SenderId = _currentUserService.UserId.Value, BeneficiarId = beneficiaryWallet.UserId, CurrencyId = walletToUpdate.CurrencyId }; await _context.TransactionsHistory.AddAsync(entity); } else { return(Result.Failure(new List <string> { "Insufficient funds" })); } await _context.SaveChangesAsync(); await transaction.CommitAsync(); return(Result.Success("Transaction was successful")); } catch (Exception e) { await transaction.RollbackAsync(); throw new Exception(e.ToString()); } }
private async Task <bool> ProcessPayment(CheckoutViewModel viewModel, User user, decimal transactionAmount, List <Team> teams) { bool success = true; var connectionInfo = new ConnectionInformation { AppKey = AppSettings.Payment.ClientId, AppSecret = AppSettings.Payment.ClientSecret, Url = AppSettings.Payment.BaseUrl }; var paymentInfo = new PaymentInformation { FirstName = viewModel.CcInfo.FirstName, LastName = viewModel.CcInfo.LastName, Address1 = viewModel.CcInfo.Address, City = viewModel.CcInfo.City, State = viewModel.CcInfo.State, PostalCode = viewModel.CcInfo.PostalCode, Country = viewModel.CcInfo.CountryCode, PhoneNumber = user.PhoneNumber, EmailAddress = user.Email, CreditCardNumber = viewModel.CcInfo.CardNumber, ExpirationDate = new DateTime(viewModel.CcInfo.Year, viewModel.CcInfo.Month, 1), Csc = viewModel.CcInfo.Cvv, TransactionAmount = transactionAmount, }; ITransactionResponse response = await PaymentService.ProcessPaymentAsync(connectionInfo, paymentInfo); if (response != null && response.IsSuccess) { foreach (Team team in teams) { team.PaymentTransactionId = response.TransactionId; } var transaction = new TransactionHistory() { ManagerId = Convert.ToInt32(User.FindFirstValue(ClaimTypes.NameIdentifier)), Amount = transactionAmount, PaymentStatus = response.PaymentStatus, TransactionDate = response.TransactionDate, TransactionId = response.TransactionId }; await TeamRepository.SaveAsync(); TransactionHistoryRepository.InsertOrUpdate(transaction); await TransactionHistoryRepository.SaveAsync(); } else { success = false; // need to log full response that came back } return(success); }
static void PreserveTransactionHistory(ATMContext context, string cardNumber, decimal amount) { TransactionHistory transactionHistory = new TransactionHistory(); transactionHistory.Amount = amount; transactionHistory.CardNumber = cardNumber; context.TransactionHistories.Add(transactionHistory); }
// PUT api/awbuildversion/5 public void Put(TransactionHistory value) { var GetActionType = Request.Headers.Where(x => x.Key.Equals("ActionType")).FirstOrDefault(); if (GetActionType.Key != null) { if (GetActionType.Value.ToList()[0].Equals("DELETE")) adventureWorks_BC.TransactionHistoryDelete(value); if (GetActionType.Value.ToList()[0].Equals("UPDATE")) adventureWorks_BC.TransactionHistoryUpdate(value); } }
/// <summary> /// Saves the transaction to a log. /// </summary> /// <param name="sum">The sum.</param> /// <param name="cardNumber">The card number.</param> private static void LogTransaction(decimal sum, string cardNumber) { using (var atmDbContext = new ATMContext()) { TransactionHistory tranLog = new TransactionHistory { CardNumber = cardNumber, Ammount = sum, TransactionDate = DateTime.Now, }; atmDbContext.TransactionsHistory.Add(tranLog); atmDbContext.SaveChanges(); } }
public static void ShowResults(string title, TransactionHistory[] transactions) { var count = 0; ShowHeader(title, transactions.Count()); foreach (var trans in transactions) { Console.WriteLine( "{0} {1} {2} {3} {4}", trans.TransactionId.ToString().PadRight(8), trans.SourceAccountNumber.PadRight(15), trans.TransactionType.PadRight(25), trans.AllocationType.PadRight(5), trans.Amount.ToString("C") ); count += 1; if (count > 5) { Console.WriteLine(); return; } } Console.WriteLine(); }
// POST api/awbuildversion public void Post(TransactionHistory value) { adventureWorks_BC.TransactionHistoryAdd(value); }
/// <summary> /// Create a new TransactionHistory object. /// </summary> /// <param name="transactionID">Initial value of TransactionID.</param> /// <param name="referenceOrderID">Initial value of ReferenceOrderID.</param> /// <param name="referenceOrderLineID">Initial value of ReferenceOrderLineID.</param> /// <param name="transactionDate">Initial value of TransactionDate.</param> /// <param name="transactionType">Initial value of TransactionType.</param> /// <param name="quantity">Initial value of Quantity.</param> /// <param name="actualCost">Initial value of ActualCost.</param> /// <param name="modifiedDate">Initial value of ModifiedDate.</param> public static TransactionHistory CreateTransactionHistory(int transactionID, int referenceOrderID, int referenceOrderLineID, global::System.DateTime transactionDate, string transactionType, int quantity, decimal actualCost, global::System.DateTime modifiedDate) { TransactionHistory transactionHistory = new TransactionHistory(); transactionHistory.TransactionID = transactionID; transactionHistory.ReferenceOrderID = referenceOrderID; transactionHistory.ReferenceOrderLineID = referenceOrderLineID; transactionHistory.TransactionDate = transactionDate; transactionHistory.TransactionType = transactionType; transactionHistory.Quantity = quantity; transactionHistory.ActualCost = actualCost; transactionHistory.ModifiedDate = modifiedDate; return transactionHistory; }
private void detach_TransactionHistories(TransactionHistory entity) { this.SendPropertyChanging("TransactionHistories"); entity.PartInfo = null; }
private void attach_TransactionHistories(TransactionHistory entity) { this.SendPropertyChanging("TransactionHistories"); entity.Dealer = this; }
private void detach_TransactionHistories1(TransactionHistory entity) { this.SendPropertyChanging("TransactionHistories1"); entity.Warehouse1 = null; }
/// <summary> /// There are no comments for TransactionHistory in the schema. /// </summary> public void AddToTransactionHistory(TransactionHistory transactionHistory) { base.AddObject("TransactionHistory", transactionHistory); }