public async Task <IActionResult> PutCustomer(string id, Customer customer) { if (id != customer.Id) { return(BadRequest()); } _context.Entry(customer).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!CustomerExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <DepositResponse> Handle(DepositCommand command, CancellationToken cancellationToken) { var response = new DepositResponse(); using (var trans = _context.Database.BeginTransaction()) { try { var wallet = _context.Wallets.Where (s => s.WalletTypeId == command.WalletTypeId) .FirstOrDefault(); decimal BalanceBefore = wallet.Balance; DateTime TransDate = DateTime.Now; if (wallet != null) { wallet.Balance = wallet.Balance + command.Amount; } await _context.SaveChangesAsync(); Transaction transaction = new Transaction { Amount = command.Amount, Status = TransactionStatusEnum.SUCCESS.ToString(), TransDate = TransDate, TransactionTypeId = command.TransactionTypeId, WalletDesId = wallet.WalletId, TransType = TransactionTypeEnum.DEPOSIT.ToString(), Fee = command.Fee }; _context.Transactions.Add(transaction); await _context.SaveChangesAsync(); TransactionLog transactionLog = new TransactionLog() { AccountId = wallet.AccountId, BalanceAfter = wallet.Balance, BalanceBefore = BalanceBefore, Status = TransactionStatusEnum.SUCCESS.ToString(), TransactionDate = TransDate, TransactionId = transaction.TransactionId, TransactionTypeId = transaction.TransactionTypeId, }; _context.TransactionLogs.Add(transactionLog); await _context.SaveChangesAsync(); trans.Commit(); response.Data.Balance = wallet.Balance; response.Data.TransactionId = transaction.TransactionId; } catch (Exception ex) { trans.Rollback(); response.Code = ErrorCode.GetError(ErrorCode.SystemError).Key; response.Message = ErrorCode.GetError(ErrorCode.SystemError).Value; Logger.Error(ex); } } return(await Task.FromResult(response)); }
public Task <LoginResponse> Handle(LoginCommand command, CancellationToken cancellationToken) { var response = new LoginResponse(); try { var account = _context.Accounts .Where(s => s.PinCode == command.PinCode) .FirstOrDefault(); if (account != null) { var traceLogin = new TraceLogin { AccountId = account.AccountId, CountLoginFail = 0, IsLoginSuccess = true, TimeLogin = DateTime.Now }; _context.TraceLogin.Add(traceLogin); _context.SaveChangesAsync(); response.Data.AccountName = account.AccountName; } else { var traceLogin = _context.TraceLogin.LastOrDefault(); if (traceLogin != null) { traceLogin.CountLoginFail = traceLogin.CountLoginFail + 1; if (traceLogin.CountLoginFail == 3) { account = _context.Accounts.FirstOrDefault(); account.isLock = true; } _context.SaveChangesAsync(); } response.Code = ErrorCode.GetError(ErrorCode.PinWrong).Key; response.Message = ErrorCode.GetError(ErrorCode.PinWrong).Value; } } catch (Exception ex) { response.Code = ErrorCode.GetError(ErrorCode.SystemError).Key; response.Message = ErrorCode.GetError(ErrorCode.SystemError).Value; Logger.Error(ex); } return(Task.FromResult(response)); }
public async Task EditAsync_ShouldEditACard() { using (var db = new ATMContext(TestOptions.TestDbContextOptions <ATMContext>())) { // Arrange var initCards = SampleData.CREDITCARDS; await db.AddRangeAsync(initCards); await db.SaveChangesAsync(); IRepository <CreditCard> repository = new DbCreditCardRepository(db); var expectedCards = await repository.GetAllAsync(); var cardToEdit = expectedCards.First(); expectedCards.Remove(cardToEdit); cardToEdit.Balance -= 1.00M; expectedCards.Add(cardToEdit); // Act await repository.EditAsync(cardToEdit); var result = await repository.GetAllAsync(); // Assert var actualCards = Assert.IsAssignableFrom <List <CreditCard> >(result); Assert.Equal( expectedCards.OrderBy(x => x.Id).Select(x => (id: x.Id, number: x.Number, pin: x.Pin, balance: x.Balance, isValid: x.IsValid)), actualCards.OrderBy(x => x.Id).Select(x => (id: x.Id, number: x.Number, pin: x.Pin, balance: x.Balance, isValid: x.IsValid))); } }
public async Task AddAsync_ShouldAddANewAction() { using (var db = new ATMContext(TestOptions.TestDbContextOptions <ATMContext>())) { // Arrange var expectedDbAction = ACTION_NOT_IN_SEEDING_ACTIONS; var initActions = ACTION_RESULTS; if (initActions.Exists(a => a.Id == expectedDbAction.Id)) { throw new InvalidOperationException($"Seeding actions already contain the action that is not supposed to be there: {expectedDbAction}"); } await db.AddRangeAsync(initActions); await db.SaveChangesAsync(); IRepository <UserActionResult> repository = new DBUserActionResultRepository(db); var expectedActions = await repository.GetAllAsync(); expectedActions.Add(expectedDbAction); // Act await repository.AddAsync(expectedDbAction); var result = await repository.GetAllAsync(); // Assert var actualActions = Assert.IsAssignableFrom <List <UserActionResult> >(result); Assert.Equal( expectedActions.OrderBy(x => x.Id).Select(x => (id: x.Id, cid: x.CreditCardId, time: x.TimeStamp, operationCode: x.OperationCode, withdrawal: x.WithdrawalAmount)), actualActions.OrderBy(x => x.Id).Select(x => (id: x.Id, cid: x.CreditCardId, time: x.TimeStamp, operationCode: x.OperationCode, withdrawal: x.WithdrawalAmount))); } }
public async Task AddAsync_ShouldAddANewCard() { using (var db = new ATMContext(TestOptions.TestDbContextOptions <ATMContext>())) { // Arrange var expectedDbCard = SampleData.CARD_NOT_ON_THE_LIST; var initCards = SampleData.CREDITCARDS; if (initCards.Exists(cc => cc.Id == expectedDbCard.Id || cc.Number == expectedDbCard.Number)) { throw new InvalidOperationException($"Seeding cards already contain the card that is not supposed to be there: {expectedDbCard}"); } await db.AddRangeAsync(initCards); await db.SaveChangesAsync(); IRepository <CreditCard> repository = new DbCreditCardRepository(db); var expectedCards = await repository.GetAllAsync(); expectedCards.Add(expectedDbCard); // Act await repository.AddAsync(expectedDbCard); var result = await repository.GetAllAsync(); // Assert var actualCards = Assert.IsAssignableFrom <List <CreditCard> >(result); Assert.Equal( expectedCards.OrderBy(x => x.Id).Select(x => (id: x.Id, number: x.Number, pin: x.Pin, balance: x.Balance, isValid: x.IsValid)), actualCards.OrderBy(x => x.Id).Select(x => (id: x.Id, number: x.Number, pin: x.Pin, balance: x.Balance, isValid: x.IsValid))); } }
public async Task EditAsync_ShouldEditACard() { using (var db = new ATMContext(TestOptions.TestDbContextOptions <ATMContext>())) { // Arrange var initCards = ACTION_RESULTS; await db.AddRangeAsync(initCards); await db.SaveChangesAsync(); IRepository <UserActionResult> repository = new DBUserActionResultRepository(db); var expectedCards = await repository.GetAllAsync(); var cardToEdit = expectedCards.First(); expectedCards.Remove(cardToEdit); cardToEdit.WithdrawalAmount += 1.00M; expectedCards.Add(cardToEdit); // Act await repository.EditAsync(cardToEdit); var result = await repository.GetAllAsync(); // Assert var actualCards = Assert.IsAssignableFrom <List <UserActionResult> >(result); Assert.Equal( expectedCards.OrderBy(x => x.Id).Select(x => (id: x.Id, cid: x.CreditCardId, time: x.TimeStamp, operationCode: x.OperationCode, withdrawal: x.WithdrawalAmount)), actualCards.OrderBy(x => x.Id).Select(x => (id: x.Id, cid: x.CreditCardId, time: x.TimeStamp, operationCode: x.OperationCode, withdrawal: x.WithdrawalAmount))); } }
public async Task AddAsync_ShouldNotAddAAction() { using (var db = new ATMContext(TestOptions.TestDbContextOptions <ATMContext>())) { // Arrange var expectedAction = ACTION_RESULTS.First(); await db.AddRangeAsync(ACTION_RESULTS); await db.SaveChangesAsync(); IRepository <UserActionResult> repository = new DBUserActionResultRepository(db); var expectedActions = await repository.GetAllAsync(); // Act Func <Task> action = async() => await repository.AddAsync(expectedAction); // Assert await Assert.ThrowsAsync <ArgumentException>(action); } }
public async Task GetBuIdAsync_ShouldReturnNoCard() { using (var db = new ATMContext(TestOptions.TestDbContextOptions <ATMContext>())) { // Arrange await db.AddRangeAsync(SampleData.CREDITCARDS); await db.SaveChangesAsync(); CreditCard expectedDbCard = null; int cardId = db.CreditCards.OrderBy(x => x.Id).Last().Id + 1; IRepository <CreditCard> repository = new DbCreditCardRepository(db); // Act var result = await repository.GetByIdAsync(cardId); // Assert Assert.Equal(expectedDbCard, result); } }
public async Task GetBuIdAsync_ShouldReturnNoAction() { using (var db = new ATMContext(TestOptions.TestDbContextOptions <ATMContext>())) { // Arrange await db.AddRangeAsync(ACTION_RESULTS); await db.SaveChangesAsync(); UserActionResult expectedDbAction = null; int actionId = db.ActionResults.OrderBy(x => x.Id).Last().Id + 1; IRepository <UserActionResult> repository = new DBUserActionResultRepository(db); // Act var result = await repository.GetByIdAsync(actionId); // Assert Assert.Equal(expectedDbAction, result); } }
public async Task GetBuIdAsync_ShouldReturnAAction() { using (var db = new ATMContext(TestOptions.TestDbContextOptions <ATMContext>())) { // Arrange var expectedAction = ACTION_RESULTS.First(); await db.AddRangeAsync(ACTION_RESULTS); await db.SaveChangesAsync(); var expectedDbAction = ACTION_RESULTS.First(); int actionId = expectedDbAction.Id; IRepository <UserActionResult> repository = new DBUserActionResultRepository(db); // Act var result = await repository.GetByIdAsync(actionId); // Assert Assert.Equal(expectedDbAction, result); } }
public async Task GetBuIdAsync_ShouldReturnACard() { using (var db = new ATMContext(TestOptions.TestDbContextOptions <ATMContext>())) { // Arrange var expectedCard = SampleData.CREDITCARDS.First(); await db.AddRangeAsync(SampleData.CREDITCARDS); await db.SaveChangesAsync(); var expectedDbCard = await db.CreditCards.Where(x => x.Number == expectedCard.Number).FirstAsync(); int cardId = expectedDbCard.Id; IRepository <CreditCard> repository = new DbCreditCardRepository(db); // Act var result = await repository.GetByIdAsync(cardId); // Assert Assert.Equal(expectedDbCard, result); } }
public async Task AddAsync_ShouldNotAddACard() { using (var db = new ATMContext(TestOptions.TestDbContextOptions <ATMContext>())) { // Arrange var expectedCard = SampleData.CREDITCARDS.First(); await db.AddRangeAsync(SampleData.CREDITCARDS); await db.SaveChangesAsync(); var expectedDbCard = await db.CreditCards.Where(x => x.Number == expectedCard.Number).FirstAsync(); IRepository <CreditCard> repository = new DbCreditCardRepository(db); var expectedCards = await repository.GetAllAsync(); // Act Func <Task> action = async() => await repository.AddAsync(expectedDbCard); // Assert await Assert.ThrowsAsync <ArgumentException>(action); } }
public async Task GetAllAsync_ShouldReturnSeedingActions() { using (var db = new ATMContext(TestOptions.TestDbContextOptions <ATMContext>())) { // Arrange var expectedResults = ACTION_RESULTS; await db.AddRangeAsync(expectedResults); await db.SaveChangesAsync(); IRepository <UserActionResult> repository = new DBUserActionResultRepository(db); // Act var result = await repository.GetAllAsync(); // Assert var actualMessages = Assert.IsAssignableFrom <List <UserActionResult> >(result); Assert.Equal( expectedResults.OrderBy(x => x.Id).Select(x => (id: x.Id, cid: x.CreditCardId, time: x.TimeStamp, operationCode: x.OperationCode, withdrawal: x.WithdrawalAmount)), actualMessages.OrderBy(x => x.Id).Select(x => (id: x.Id, cid: x.CreditCardId, time: x.TimeStamp, operationCode: x.OperationCode, withdrawal: x.WithdrawalAmount))); } }
public async Task EditAsync_ShouldNotEdit() { using (var db = new ATMContext(TestOptions.TestDbContextOptions <ATMContext>())) { // Arrange var cardToEdit = ACTION_NOT_IN_SEEDING_ACTIONS; var initCards = ACTION_RESULTS; if (initCards.Exists(cc => cc.Id == cardToEdit.Id)) { throw new InvalidOperationException($"Seeding cards already contain the card that is not supposed to be there: {cardToEdit}"); } await db.AddRangeAsync(initCards); await db.SaveChangesAsync(); IRepository <UserActionResult> repository = new DBUserActionResultRepository(db); // Act Func <Task> action = async() => await repository.EditAsync(cardToEdit); // Assert await Assert.ThrowsAsync <ArgumentException>(action); } }
public async Task EditAsync_ShouldNotEdit() { using (var db = new ATMContext(TestOptions.TestDbContextOptions <ATMContext>())) { // Arrange var cardToEdit = SampleData.CARD_NOT_ON_THE_LIST; var initCards = SampleData.CREDITCARDS; if (initCards.Exists(cc => cc.Id == cardToEdit.Id || cc.Number == cardToEdit.Number)) { throw new InvalidOperationException($"Seeding cards already contain the card that is not supposed to be there: {cardToEdit}"); } await db.AddRangeAsync(initCards); await db.SaveChangesAsync(); IRepository <CreditCard> repository = new DbCreditCardRepository(db); // Act Func <Task> action = async() => await repository.EditAsync(cardToEdit); // Assert await Assert.ThrowsAsync <ArgumentException>(action); } }
public async Task <WithdrawResponse> Handle(WithdrawCommand command, CancellationToken cancellationToken) { var response = new WithdrawResponse(); using (var trans = _context.Database.BeginTransaction()) { try { // hạn mức tối đa 5.000.000 if (command.Amount > 5000000) { response.Code = ErrorCode.GetError(ErrorCode.OutRange).Key; response.Message = ErrorCode.GetError(ErrorCode.OutRange).Value; return(await Task.FromResult(response)); } var wallet = _context.Wallets.Where (s => s.WalletTypeId == command.WalletTypeId) .FirstOrDefault(); // trong tk còn ít nhất 50.000 if (wallet.Balance < command.Amount - 50000 - command.Fee) { response.Code = ErrorCode.GetError(ErrorCode.AmountNotEnough).Key; response.Message = ErrorCode.GetError(ErrorCode.AmountNotEnough).Value; return(await Task.FromResult(response)); } decimal BalanceBefore = wallet.Balance; DateTime TransDate = DateTime.Now; if (wallet != null) { wallet.Balance = wallet.Balance - command.Amount - command.Fee; } await _context.SaveChangesAsync(); Transaction transaction = new Transaction { Amount = command.Amount, Status = TransactionStatusEnum.SUCCESS.ToString(), TransDate = TransDate, TransactionTypeId = command.TransactionTypeId, WalletDesId = wallet.WalletId, TransType = TransactionTypeEnum.WITHDRAW.ToString(), Fee = command.Fee }; _context.Transactions.Add(transaction); await _context.SaveChangesAsync(); TransactionLog transactionLog = new TransactionLog() { AccountId = wallet.AccountId, BalanceAfter = wallet.Balance, BalanceBefore = BalanceBefore, Status = TransactionStatusEnum.SUCCESS.ToString(), TransactionDate = TransDate, TransactionId = transaction.TransactionId, TransactionTypeId = transaction.TransactionTypeId }; _context.TransactionLogs.Add(transactionLog); await _context.SaveChangesAsync(); trans.Commit(); response.Data.Balance = wallet.Balance; response.Data.TransactionId = transaction.TransactionId; } catch (Exception ex) { trans.Rollback(); response.Code = ErrorCode.GetError(ErrorCode.SystemError).Key; response.Message = ErrorCode.GetError(ErrorCode.SystemError).Value; Logger.Error(ex); } } return(await Task.FromResult(response)); }
public async Task ChangePIN(Card card) { _context.Update(card); await _context.SaveChangesAsync(); }
public async Task <TransferResponse> Handle(TransferCommand command, CancellationToken cancellationToken) { var response = new TransferResponse(); using (var trans = _context.Database.BeginTransaction()) { try { DateTime TransDate = DateTime.Now; var walletSource = _context.Wallets.Where (s => s.WalletId == command.WalletSourceId) .FirstOrDefault(); if (walletSource.Balance < command.Amount - 50000 - command.Fee) { response.Code = ErrorCode.GetError(ErrorCode.AmountNotEnough).Key; response.Message = ErrorCode.GetError(ErrorCode.AmountNotEnough).Value; return(await Task.FromResult(response)); } decimal BeforeBalanceSource = walletSource.Balance; if (walletSource != null) { walletSource.Balance = walletSource.Balance - command.Amount - command.Fee; } await _context.SaveChangesAsync(); var walletDes = _context.Wallets.Where (s => s.WalletId == command.WalletDesId) .FirstOrDefault(); decimal BeforeBalanceDes = walletDes.Balance; if (walletDes != null) { walletDes.Balance = walletDes.Balance + command.Amount; } await _context.SaveChangesAsync(); Transaction transaction = new Transaction { Amount = command.Amount, Status = TransactionStatusEnum.SUCCESS.ToString(), TransDate = TransDate, TransactionTypeId = command.TransactionTypeId, WalletDesId = walletDes.WalletId, WalletSourceId = walletSource.WalletId, TransType = TransactionTypeEnum.TRANSFER.ToString(), Fee = command.Fee }; _context.Transactions.Add(transaction); await _context.SaveChangesAsync(); TransactionLog transactionLogSource = new TransactionLog() { AccountId = walletSource.AccountId, BalanceAfter = walletSource.Balance, BalanceBefore = BeforeBalanceSource, Status = TransactionStatusEnum.SUCCESS.ToString(), TransactionDate = TransDate, TransactionId = transaction.TransactionId, TransactionTypeId = transaction.TransactionTypeId }; _context.TransactionLogs.Add(transactionLogSource); await _context.SaveChangesAsync(); TransactionLog transactionLogDes = new TransactionLog() { AccountId = walletSource.AccountId, BalanceAfter = walletDes.Balance, BalanceBefore = BeforeBalanceDes, Status = TransactionStatusEnum.SUCCESS.ToString(), TransactionDate = TransDate, TransactionId = transaction.TransactionId, TransactionTypeId = transaction.TransactionTypeId }; _context.TransactionLogs.Add(transactionLogDes); await _context.SaveChangesAsync(); response.Data.TransactionId = transaction.TransactionId; trans.Commit(); } catch (Exception ex) { trans.Rollback(); response.Code = ErrorCode.GetError(ErrorCode.SystemError).Key; response.Message = ErrorCode.GetError(ErrorCode.SystemError).Value; Logger.Error(ex); } } return(await Task.FromResult(response)); }
public async Task AddAsync(CreditCard entity) { _context.Add(entity); await _context.SaveChangesAsync(); }
public async Task AddAsync(UserActionResult entity) { _context.Add(entity); await _context.SaveChangesAsync(); }