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