public async Task <DTO.UnitOutput> RemoveEntityByIdAsync(long id)
{
try
{
await TransactionHandler.BeginTransactionAsync();
var unitToRemove = await UnitRepository.GetEntityAsync(filter : u => u.Id == id, includes : Includes);
if (unitToRemove.Articles != null && unitToRemove.Articles.Count > 0)
{
throw new BadRequestException("This unit is used by another article.");
}
var removedUnit = await UnitRepository.RemoveEntityAsync(unitToRemove);
await TransactionHandler.CommitTransactionAsync();
return(Mapper.Map <DTO.UnitOutput>(removedUnit));
}
catch
{
await TransactionHandler.RollbackTransactionAsync();
throw;
}
finally
{
await TransactionHandler.DisposeTransactionAsync();
}
}
public async Task ShouldReturnListofTransactionViewModelWithDataWhenTrueLayerApiReturnsData()
{
var mockAccountService = new Mock <IAccountService>();
var mockTransactionService = new Mock <ITransactionService>();
var mockStorage = new Mock <IStorage>();
var accounts = new List <AccountModel>
{
new AccountModel
{
AccountId = "testAccountId",
AccountName = "TestAccount",
AccountType = "TestAccountType"
}
};
var transactions = new List <TransactionModel> {
new TransactionModel
{
Amount = 1,
Description = "testDesc",
TransactionCategory = "testCategory",
TransactionType = "testTransaction"
}
};
mockAccountService.Setup(x => x.GetAllBankAccounts()).ReturnsAsync(accounts);
mockTransactionService.Setup(x => x.GetTransactionByAccountId(accounts[0].AccountId)).ReturnsAsync(transactions);
var handler = new TransactionHandler(mockAccountService.Object, mockTransactionService.Object, mockStorage.Object);
var result = await handler.Handle(It.IsAny <GetTransactionQuery>(), It.IsAny <CancellationToken>());
Assert.IsTrue(result.Response.Count > 0);
Assert.IsInstanceOfType(result.Response, typeof(List <TransactionViewModel>));
}
/// <summary>
/// Be notified (called back) when the local copy of the blockchain is updated at the transaction level.
/// </summary>
/// <param name="handler"> Callback which will be called when a transaction is added. </param>
public void SubscribeToTransaction(TransactionHandler handler)
{
var handlerHandle = GCHandle.Alloc(handler);
var handlerPtr = (IntPtr)handlerHandle;
ExecutorNative.chain_subscribe_transaction(nativeInstance_, Chain.NativeInstance, handlerPtr, internalTxHandler_);
}
public async Task DeleteTransactionForCurrentUser(int transactionId)
{
var userId = await _authenticationService.GetCurrentUserId();
using var unitOfWork = _unitOfWork();
var transaction = await unitOfWork.TransactionRepository.FindSingleTracked(item =>
item.Id == transactionId && item.UserId == userId,
includeProperties : new string[] {
nameof(TransactionEntity.BankAccount)
});
if (transaction == null)
{
throw new NotFoundException(nameof(TransactionEntity));
}
if (transaction.TransactionCategories != null)
{
unitOfWork.TransactionCategoryRepository.DeleteRange(transaction.TransactionCategories);
}
unitOfWork.TransactionRepository.Delete(transaction);
await unitOfWork.SaveAsync();
transaction.BankAccount.CurrentBalance = await TransactionHandler.CalculateCurrentBalanceForBankAccount(unitOfWork, transaction.BankAccount);
await unitOfWork.SaveAsync();
}
public static bool updateToApproved(int id)
{
Transaction trans = TransactionHandler.getSingleTransaction(id);
TransactionRepository.updateTransaction(trans.TransactionId, "Approved", trans.Quantity, trans.Subtotal);
return(true);
}
public async Task <TransactionModel> CreateTransactionForCurrentUser(TransactionModel transactionModel)
{
var userId = await _authenticationService.GetCurrentUserId();
using var unitOfWork = _unitOfWork();
var bankAccount = await unitOfWork.BankAccountRepository.FindSingleTracked(x => x.UserId == userId && x.Id == transactionModel.BankAccountId);
if (bankAccount == null)
{
throw new NotFoundException(nameof(BankAccountEntity));
}
var transactionEntity = transactionModel.ToNewEntity(userId);
unitOfWork.TransactionRepository.Insert(transactionEntity);
await unitOfWork.SaveAsync();
// First save the transaction, then recalculate the balance.
bankAccount.CurrentBalance = await TransactionHandler.CalculateCurrentBalanceForBankAccount(unitOfWork, bankAccount);
await unitOfWork.SaveAsync();
return(transactionEntity.ToDto());
}
public ActionResult TransactionDetails(int transactionId)
{
Transaction transaction = TransactionHandler.getTransaction(transactionId);
Profile buyer = ProfileHandler.GetProfile(transaction.BuyerId);
Profile seller = ProfileHandler.GetProfile(transaction.SellerId);
if (User.Identity.Name == buyer.Email)
{
transaction.CurrentUser = ActionBy.Buyer;
transaction.CounterPartyName = seller.Name;
}
else
{
transaction.CurrentUser = ActionBy.Seller;
transaction.CounterPartyName = buyer.Name;
}
if ((transaction.CurrentUser == ActionBy.Buyer && transaction.Confirmed == Confirmed.ByBuyer) ||
(transaction.CurrentUser == ActionBy.Seller && transaction.Confirmed == Confirmed.BySeller))
{
transaction.ConfirmedByCurrentUser = true;
}
else
{
transaction.ConfirmedByCurrentUser = false;
}
TransactionCommentModel model = new TransactionCommentModel(transaction, User.Identity.Name);
return(View(model));
}
public async Task <DTO.CountryOutput> RemoveEntityByIdAsync(long id)
{
try
{
await TransactionHandler.BeginTransactionAsync();
var countryToRemove =
await CountryRepository.GetEntityAsync(filter : c => c.Id == id, includes : Includes);
if (countryToRemove.Addresses != null && countryToRemove.Addresses.Count > 0)
{
throw new BadRequestException("This country is used by another address.");
}
var removedCountry = await CountryRepository.RemoveEntityAsync(countryToRemove);
await TransactionHandler.CommitTransactionAsync();
return(Mapper.Map <DTO.CountryOutput>(removedCountry));
}
catch
{
await TransactionHandler.RollbackTransactionAsync();
throw;
}
finally
{
await TransactionHandler.DisposeTransactionAsync();
}
}
public async Task <IActionResult> PaymentConfirm(Payment payment, string code)
{
var t = HttpContext.Session.GetInt32("Payment");
if (t == null)
{
RedirectToAction(nameof(Payment));
}
if (TransactionHandler.IsValid((int)t, code))
{
User user = null;
string userId = HttpContext.Session.GetString("UserId");
SessionHandler.GetUser(userId, out user);
try
{
await _context.MakePayment(user, payment);
}
catch
{
return(Redirect("/Home/Error"));
}
return(RedirectToAction(nameof(PaymentList)));
}
else
{
ViewBag.ErrMsg = "Wrong confirmation code!";
return(View(payment));
}
}
public async Task <DTO.CountryOutput> UpdateEntityAsync(long id, DTO.CountryInput entity)
{
try
{
await TransactionHandler.BeginTransactionAsync();
var foundCountry = await CountryRepository.GetEntityByIdAsync(id);
if (foundCountry == null)
{
throw new NotFoundException("This country does not exist.");
}
foundCountry.Code = entity.Code;
foundCountry.Name = entity.Name;
await CountryRepository.UpdateEntityAsync(foundCountry);
await TransactionHandler.CommitTransactionAsync();
return(Mapper.Map <DTO.CountryOutput>(foundCountry));
}
catch
{
await TransactionHandler.RollbackTransactionAsync();
throw;
}
finally
{
await TransactionHandler.DisposeTransactionAsync();
}
}
private void DataPortal_Fetch(TapMangoPlant.Criteria criteria)
{
TransactionHandler.ProcessTransaction((tr) =>
{
using (var cm = tr.CreateCommand())
{
this.RaiseListChangedEvents = false;
cm.CommandText = "usp_TapMangoPlant";
cm.CommandType = CommandType.StoredProcedure;
cm.Parameters.AddWithValue("@action", criteria.Action);
cm.Parameters.AddWithValue("@Id", criteria.Id);
using (var dr = new SafeDataReader(cm.ExecuteReader()))
{
while (dr.Read())
{
this.Add(new TapMangoPlant(dr));
}
}
this.RaiseListChangedEvents = true;
}
});
}
public async Task <IActionResult> Payment(Payment payment)
{
ViewBag.Templates = await GetTemplates();
ViewBag.BankCodes = DataHandler.GetBankCodes();
if (ModelState.IsValid)
{
User user = null;
string userId = HttpContext.Session.GetString("UserId");
SessionHandler.GetUser(userId, out user);
if (user.Money < payment.Amount)
{
ViewBag.Insufficient = "Insufficient money.";
return(View(payment));
}
if (payment.DestBank == 666 && !_context.AccountExist(payment.DestAccount))
{
return(View("NoAccount", payment));
}
int t = TransactionHandler.NewPayment(user, payment);
HttpContext.Session.SetInt32("Payment", t);
return(View("PaymentConfirm", payment));
}
ViewBag.ErrMsg = "Values are not valid.";
return(View(payment));
}
public override void OnAfterSimulationTick()
{
// Normally, the game is paused when the player is in Esc or similar menus. We ignore this setting.
if (SimulationManager.instance.ForcedSimulationPaused && MultiplayerManager.Instance.CurrentRole != MultiplayerRole.None)
{
SimulationManager.instance.ForcedSimulationPaused = false;
}
if (_lastSelectedSimulationSpeed != SimulationManager.instance.SelectedSimulationSpeed)
{
Command.SendToAll(new SpeedCommand
{
SelectedSimulationSpeed = SimulationManager.instance.SelectedSimulationSpeed
});
}
if (_lastSimulationPausedState != SimulationManager.instance.SimulationPaused)
{
Command.SendToAll(new PauseCommand
{
SimulationPaused = SimulationManager.instance.SimulationPaused
});
}
_lastSimulationPausedState = SimulationManager.instance.SimulationPaused;
_lastSelectedSimulationSpeed = SimulationManager.instance.SelectedSimulationSpeed;
// Finish transactions
TransactionHandler.FinishSend();
}
public async Task ShouldReturnTransactionViewModelWithOutDataWhenTrueLayerTransactionApiEndpointDoesNotReturnsData()
{
var mockAccountService = new Mock <IAccountService>();
var mockTransactionService = new Mock <ITransactionService>();
var mockStorage = new Mock <IStorage>();
var accounts = new List <AccountModel>
{
new AccountModel
{
AccountId = "testAccountId",
AccountName = "TestAccount",
AccountType = "TestAccountType"
}
};
mockAccountService.Setup(x => x.GetAllBankAccounts()).ReturnsAsync(new List <AccountModel>());
mockTransactionService.Setup(x => x.GetTransactionByAccountId(accounts[0].AccountId)).ReturnsAsync(new List <TransactionModel>());
var handler = new TransactionHandler(mockAccountService.Object, mockTransactionService.Object, mockStorage.Object);
var result = await handler.Handle(It.IsAny <GetTransactionQuery>(), It.IsAny <CancellationToken>());
Assert.IsTrue(result.Response.Count == 0);
Assert.IsInstanceOfType(result.Response, typeof(List <TransactionViewModel>));
}
public async Task <DTO.ArticleOutput> RemoveEntityByIdAsync(long id, string userName, string normalizedUserName)
{
try
{
await TransactionHandler.BeginTransactionAsync();
var foundArticle = await CheckAccessRightsAndGetArticleAsync(id, userName, normalizedUserName);
var removedArticle = await ArticleRepository.RemoveEntityAsync(foundArticle);
await TransactionHandler.CommitTransactionAsync();
return(Mapper.Map <DTO.ArticleOutput>(removedArticle));
}
catch
{
await TransactionHandler.RollbackTransactionAsync();
throw;
}
finally
{
await TransactionHandler.DisposeTransactionAsync();
}
}
public TransactionHandlerTests()
{
_accountRepository = Substitute.For <IAccountRepository>();
_transactionRepository = Substitute.For <ITransactionRepository>();
_uow = Substitute.For <IUnitOfWork>();
_transactionHandler = new TransactionHandler(_accountRepository, _transactionRepository, _uow);
}
public async void ShouldDecoratedTransactionHandlerAndThrowException()
{
var command = new AnyCommand();
var decorator = new ExceptionCommandDcorator();
var transactionHandler = new TransactionHandler <AnyCommand>(unitOfWork, decorator);
await Assert.ThrowsAsync <Exception>(() => transactionHandler.ExecuteAsync(command));
}
protected void btnCheckout_Click(object sender, EventArgs e)
{
User user = (User)Session["auth_user"];
TransactionHandler.Checkout(user, carts);
Response.Redirect("Index.aspx");
}
public void SimpleDepositTest()
{
var th = new TransactionHandler();
var result = th.Deposit(4500.00, 3);
Assert.IsNotNull(result);
Assert.AreEqual(result, "Success");
}
public void WithdrawOverLimitTest()
{
// Only Account 2 is of the type "Individual Investment"
var th = new TransactionHandler();
var result = th.Withdraw(1200, 2);
Assert.AreNotEqual(result, "Success");
}
public void HandlePlayerDisconnect(Player player)
{
MultiplayerManager.Instance.PlayerList.Remove(player.Username);
this.ConnectedPlayers.Remove(player.NetPeer.Id);
Command.HandleClientDisconnect(player);
TransactionHandler.ClearTransactions(player.NetPeer.Id);
ToolSimulator.RemoveSender(player.NetPeer.Id);
}
public CreateMovementResponse Run(CreateMovementRequest request)
{
GameEntity game = gameRepository.Retrieve(request.id);
if (game == null)
{
throw new BadRequestException("Partida não encontrada");
}
if (game.currentPlayer != TypePlayerExtension.GetByPlay(request.player))
{
throw new BadRequestException("Não é turno do jogador");
}
if (!PositionIsValid(request.position, game))
{
throw new BadRequestException("Espaço inválido");
}
MovementEntity movement = new MovementEntity()
{
gameId = request.id,
player = TypePlayerExtension.GetByPlay(request.player),
turn = game.turn,
x = request.position.x,
y = request.position.y
};
game = TransactionHandler.HandleTransaction(() =>
{
movementRepository.Create(movement);
return(gameRepository.RegisterMovement(request.id, movement));
});
string winner = CheckForWinner(game.board);
string msg = null;
if (game.turn >= 9 && winner == null)
{
winner = "Draw";
}
if (winner != null)
{
msg = "Partida finalizada";
}
else
{
msg = "Partida em andamento";
}
return(new CreateMovementResponse()
{
msg = msg,
winner = winner
});
}
public ActionResult CancelTransaction(Transaction transaction)
{
if (ModelState.IsValid)
{
TransactionHandler.CancelTransaction(transaction);
}
return(RedirectToAction("Index", "Home"));
}
public async void ShouldDecoratedTransactionHandlerAndSum()
{
var command = new AnyCommand();
var decorator = new AnyCommandDcorator();
var transactionHandler = new TransactionHandler <AnyCommand>(unitOfWork, decorator);
await transactionHandler.ExecuteAsync(command);
Assert.Equal(1, command.Cout);
}
public override void Handle(ClientDisconnectCommand command)
{
LogManager.GetCurrentClassLogger().Info($"Player {command.Username} has disconnected!");
ChatLogPanel.PrintGameMessage($"Player {command.Username} has disconnected!");
MultiplayerManager.Instance.PlayerList.Remove(command.Username);
TransactionHandler.ClearTransactions(command.ClientId);
}
public static HeaderTransaction createHeaderTransaction(int UserID, int PaymentTypeID)
{
HeaderTransaction ht = new HeaderTransaction();
ht.ID = TransactionHandler.getLastTransactionID() + 1;
ht.UserID = UserID;
ht.PaymentTypeID = PaymentTypeID;
ht.Date = DateTime.Now;
return(ht);
}
protected override void Handle(ClientDisconnectCommand command)
{
Log.Info($"Player {command.Username} has disconnected!");
ChatLogPanel.PrintGameMessage($"Player {command.Username} has disconnected!");
MultiplayerManager.Instance.PlayerList.Remove(command.Username);
TransactionHandler.ClearTransactions(command.ClientId);
ToolSimulator.RemoveSender(command.ClientId);
}
public UnitTests()
{
var accountHandler = new AccountHandler();
var customerHandler = new CustomerHandler();
var transactionHandler = new TransactionHandler();
var fakeFileHandler = new FakeFileHandler();
_bank = new Bank(new FakeFileHandler(), customerHandler, transactionHandler, accountHandler);
Seed();
}
/// <summary>
/// Attempt to disconnect from the server
/// </summary>
public void Disconnect()
{
// Update status and stop client
Status = ClientStatus.Disconnected;
_netClient.Stop();
MultiplayerManager.Instance.PlayerList.Clear();
TransactionHandler.ClearTransactions();
_logger.Info("Disconnected from server");
}
public TransactionController(
IAccountRepository accountRepository,
ITransactionRepository transactionRepository,
TransactionHandler transactionHandler,
IUnitOfWork uow)
{
_accountRepository = accountRepository;
_transactionRepository = transactionRepository;
_transactionHandler = transactionHandler;
_uow = uow;
}
//
// Constructie
//
private DataAccess()
{
sysLog.Info("DataAccess startup");
publicXmlRpcUrl = ConfigurationManager.AppSettings["PUBLIC_XML_RPC_SERVER"];
privateXmlRpcUrl = ConfigurationManager.AppSettings["PRIVATE_XML_RPC_SERVER"];
publicExchangeHandler = HandlerHelper.getPublicExchangeHandler(publicXmlRpcUrl);
publicIndexHandler = HandlerHelper.getPublicIndexHandler(publicXmlRpcUrl);
publicOrderHandler = HandlerHelper.getPublicOrderHandler(publicXmlRpcUrl);
publicPortfolioHandler = HandlerHelper.getPublicPortfolioHandler(publicXmlRpcUrl);
publicSecurityHandler = HandlerHelper.getPublicSecurityHandler(publicXmlRpcUrl);
publicTransactionHandler = HandlerHelper.getPublicTransactionHandler(publicXmlRpcUrl);
publicUserHandler = HandlerHelper.getPublicUserHandler(publicXmlRpcUrl);
publicPointsTransactionHandler = HandlerHelper.getPublicPointsTransactionHandler(publicXmlRpcUrl);
exchangeCache = new Dictionary<string, IExchange>();
}
