//private TerminalConnector connector;
//private int orderNumber = -1;
public MainWindow()
{
InitializeComponent();
var configurator = new Configurator("Configs/main.xml", this);
try
{
tradeController = configurator.TradeController;
Task.Run(() => tradeController.Run());
}
catch (Exception e)
{
Logger.Error(e);
}
}
public TradeControllerTests()
{
_tradeController = new TradeController(_tradeRepositoryMock.Object);
}
public TradeControllerTests()
{
_tradeController = new TradeController(_shareRepositoryMock.Object, _tradeRepositoryMock.Object, _portfolioRepositoryMock.Object);
}
public void OnCardClicked()
{
// Only visible cards that have more than 1 as their amount can be clicked.
if (!visible || !enabled)
{
return;
}
Debug.Log("Card " + unitCode + " clicked!");
// Construction cards -- Available only if the player is in the build phase.
if (IsConstructionCard())
{
if (inventory.GetPlayer().GetPhase() == GamePlayer.Phase.TRADE_BUILD_IDLE)
{
// Select
Debug.Log("Selecting " + unitCode);
DisplaySelectedCard();
inventory.GetPlayer().SetPhase(GamePlayer.Phase.BUILDING);
inventory.GetPlayer().SetSelectedConstructionCard(this);
}
else if (inventory.GetPlayer().GetPhase() == GamePlayer.Phase.BUILDING)
{
// If I am the selected card -- deselect. Otherwise, deselect other card and select this card.
if (inventory.GetPlayer().GetSelectedConstructionCard() == this)
{
// Deselect
Debug.Log("Deselecting " + unitCode);
DisplayNormalCard();
inventory.GetPlayer().SetPhase(GamePlayer.Phase.STOP_BUILDING);
}
else
{
Debug.Log("Switching selection to: " + unitCode);
DisplaySelectedCard();
Card previousSelectedCard = inventory.GetPlayer().GetSelectedConstructionCard();
previousSelectedCard.DisplayNormalCard();
inventory.GetPlayer().TurnOffIndicators();
inventory.GetPlayer().SetSelectedConstructionCard(this);
}
}
}
// Resource cards -- Clicking on these is possible if the player is currently trading or discarding their hand.
if (IsResourceCard())
{
TradeController tradeController = GameObject.Find("TradeController").GetComponent <TradeController>();
DiscardController discardController = GameObject.Find("DiscardController").GetComponent <DiscardController>();
// Check if it's in the inventory or in the trade slot.
if (gameObject.tag == "InventoryCard")
{
if (tradeController.IsTrading() && !tradeController.IsYearOfPlenty())
{
// Move 1 stock from the inventory to the local offers slot if the player isn't playing a Year of Plenty card.
inventory.TakeFromPlayer(this.unitCode, 1);
tradeController.OfferResource(this.unitCode, 1);
}
else if (discardController.IsDiscarding())
{
// Move 1 stock from the inventory to the discard slot.
inventory.TakeFromPlayer(this.unitCode, 1);
discardController.DiscardResource(this.unitCode, 1);
}
}
else if (gameObject.tag == "TradeCard")
{
// if it's the remote player card that's being clicked, do not do anything
if (tradeController.IsLocalCard(this))
{
// Move 1 stock from the offers panel to the inventory.
inventory.GiveToPlayer(this.unitCode, 1);
tradeController.RetractResourceOffer(this.unitCode, 1);
}
else
{
// If the player is trading with the supply, handle the click.
if (tradeController.IsSupplyTrading())
{
tradeController.SupplyCardChosen(this.unitCode, 1);
}
else if (tradeController.IsYearOfPlenty())
{
tradeController.YearOfPlentyCardChosen(this.unitCode, 1);
}
}
}
else if (gameObject.tag == "DiscardCard")
{
// Move 1 stock from the discard panel to the inventory.
inventory.GiveToPlayer(this.unitCode, 1);
discardController.RetractResourceDiscard(this.unitCode, 1);
}
else if (gameObject.tag == "MonopolyCard")
{
// Initialise stealing of this resource type from all the other players.
discardController.MonopolyCardClicked(this.unitCode);
}
}
// Development cards -- If they're available this turn, prompt the player to confirm whether or not to play them.
if (IsDevelopmentCard())
{
// A victory card cannot be played.
if (unitCode == Inventory.UnitCode.VICTORY_CARD)
{
return;
}
// If it is not this player's turn, disable development card usage.
if (inventory.GetPlayer().IsMyTurn() == false)
{
return;
}
// If the player is not in the IDLE phase, return.
if (inventory.GetPlayer().GetPhase() != GamePlayer.Phase.TRADE_BUILD_IDLE)
{
return;
}
// Show the play development card confirmation panel.
GameObject.Find("ShopController").GetComponent <ShopController>().PlayDevelopmentCard(this.unitCode);
}
}
public TradeSave(TradeController tc)
{
tradeOrders = new DictContainer <ItemOrder, bool>(tc.TradeOrders);
caravansThisMonth = tc.caravansThisMonth;
timeDelta = tc.TimeDelta;
}
public TradeControllerTests()
{
_tradeController = new TradeController(null, _tradeRepositoryMock.Object, null);
}
private void InstantiateManagers()
{
conMan = new ConsumptionController();
proMan = new ProductionController();
traMan = new TradeController();
}
public TradeSave(TradeController tc)
{
tradeOrders = tc.TradeOrders;
timeDelta = tc.TimeDelta;
caravanIndex = tc.CaravanIndex;
}
public void Scenario1Test_TestsScenario1AndItsOutcome_VerifiesThroughMarketDataOrderAndTradesResults()
{
// Get the context
IApplicationContext applicationContext = ContextRegistry.GetContext();
// Get the instance through Spring configuration
OrderController orderController = (OrderController)applicationContext["OrderController"];
TradeController tradeController = (TradeController)applicationContext["TradeController"];
MarketController marketController = (MarketController)applicationContext["MarketController"];
orderController.Request = new HttpRequestMessage(HttpMethod.Post, "");
orderController.Request.Headers.Add("Auth", "123456789");
tradeController.Request = new HttpRequestMessage(HttpMethod.Post, "");
tradeController.Request.Headers.Add("Auth", "123456789");
marketController.Request = new HttpRequestMessage(HttpMethod.Post, "");
marketController.Request.Headers.Add("Auth", "123456789");
Scenario1OrderCreation(orderController);
// ------------------------------- Order Book ------------------------------
IHttpActionResult orderBookResponse = marketController.GetOrderBook("BTCLTC");
OkNegotiatedContentResult <object> okOrderBookResponse =
(OkNegotiatedContentResult <object>)orderBookResponse;
OrderBookRepresentation representation = okOrderBookResponse.Content as OrderBookRepresentation;
Tuple <OrderRepresentationList, OrderRepresentationList> orderBook = new Tuple <OrderRepresentationList, OrderRepresentationList>(representation.Bids, representation.Asks);
// Item1 = Bid Book, Item1[i].Item1 = Volume of 'i' Bid, Item1[i].Item2 = Price of 'i' Bid
Assert.AreEqual(5, orderBook.Item1.ToList()[0].Volume);
Assert.AreEqual(250, orderBook.Item1.ToList()[0].Price);
Assert.AreEqual(2, orderBook.Item1.ToList()[1].Volume);
Assert.AreEqual(250, orderBook.Item1.ToList()[1].Price);
// Item2 = Ask Book, Item2[i].Item1 = Volume of Ask at index 'i', Item2[i].Item2 = Price of Ask at index 'i'
Assert.AreEqual(0, orderBook.Item2.Count());
// ------------------------------- Order Book ------------------------------
IHttpActionResult depthResponse = marketController.GetDepth("BTCLTC");
OkNegotiatedContentResult <object> okDepth
= (OkNegotiatedContentResult <object>)depthResponse;
DepthTupleRepresentation depth = okDepth.Content as DepthTupleRepresentation;
// Item1 = Bid Book, Item1.Item1 = Aggregated Volume, Item1.Item2 = Price, Item1.Item3 = Number of Orders
Assert.AreEqual(7, depth.BidDepth[0].Volume);
Assert.AreEqual(250, depth.BidDepth[0].Price);
Assert.AreEqual(2, depth.BidDepth[0].OrderCount);
Assert.IsNull(depth.BidDepth[1]);
Assert.IsNull(depth.BidDepth[2]);
Assert.IsNull(depth.BidDepth[3]);
Assert.IsNull(depth.BidDepth[4]);
// Item2 = Ask Book, Item2.Item1 = Aggregated Volume, Item2.Item2 = Price, Item2.Item3 = Number of Orders
Assert.IsNull(depth.AskDepth[0]);
Assert.IsNull(depth.AskDepth[1]);
Assert.IsNull(depth.AskDepth[2]);
Assert.IsNull(depth.AskDepth[3]);
Assert.IsNull(depth.AskDepth[4]);
//------------------- Open Orders -------------------------
IHttpActionResult openOrdersResponse = GetOpenOrders(orderController);
OkNegotiatedContentResult <List <OrderReadModel> > okOpenOrdersResponse = (OkNegotiatedContentResult <List <OrderReadModel> >)openOrdersResponse;
List <OrderReadModel> openOrders = okOpenOrdersResponse.Content;
Assert.AreEqual(2, openOrders.Count);
// First Open Order
Assert.AreEqual(250, openOrders[1].Price);
Assert.AreEqual(10, openOrders[1].Volume);
Assert.AreEqual(5, openOrders[1].VolumeExecuted);
Assert.AreEqual(5, openOrders[1].OpenQuantity);
Assert.AreEqual("Limit", openOrders[1].Type);
Assert.AreEqual("Buy", openOrders[1].Side);
Assert.AreEqual("PartiallyFilled", openOrders[1].Status);
// Second Open Order
Assert.AreEqual(250, openOrders[0].Price);
Assert.AreEqual(2, openOrders[0].Volume);
Assert.AreEqual(0, openOrders[0].VolumeExecuted);
Assert.AreEqual(2, openOrders[0].OpenQuantity);
Assert.AreEqual("Limit", openOrders[0].Type);
Assert.AreEqual("Buy", openOrders[0].Side);
Assert.AreEqual("Accepted", openOrders[0].Status);
//------------------- Open Orders -------------------------
//------------------- Closed Orders -------------------------
IHttpActionResult closedOrdersResponse = GetClosedOrders(orderController);
OkNegotiatedContentResult <List <OrderReadModel> > okClosedOrdersResponse = (OkNegotiatedContentResult <List <OrderReadModel> >)closedOrdersResponse;
List <OrderReadModel> closedOrders = okClosedOrdersResponse.Content;
Assert.AreEqual(252, closedOrders[3].Price);
Assert.AreEqual(5, closedOrders[3].Volume);
Assert.AreEqual(5, closedOrders[3].VolumeExecuted);
Assert.AreEqual(0, closedOrders[3].OpenQuantity);
Assert.AreEqual("Limit", closedOrders[3].Type);
Assert.AreEqual("Sell", closedOrders[3].Side);
Assert.AreEqual("Complete", closedOrders[3].Status);
Assert.AreEqual(0, closedOrders[2].Price);
Assert.AreEqual(3, closedOrders[2].Volume);
Assert.AreEqual(3, closedOrders[2].VolumeExecuted);
Assert.AreEqual(0, closedOrders[2].OpenQuantity);
Assert.AreEqual("Market", closedOrders[2].Type);
Assert.AreEqual("Buy", closedOrders[2].Side);
Assert.AreEqual("Complete", closedOrders[2].Status);
Assert.AreEqual(253, closedOrders[1].Price);
Assert.AreEqual(2, closedOrders[1].Volume);
Assert.AreEqual(2, closedOrders[1].VolumeExecuted);
Assert.AreEqual(0, closedOrders[1].OpenQuantity);
Assert.AreEqual("Limit", closedOrders[1].Type);
Assert.AreEqual("Buy", closedOrders[1].Side);
Assert.AreEqual("Complete", closedOrders[1].Status);
Assert.AreEqual(0, closedOrders[0].Price);
Assert.AreEqual(5, closedOrders[0].Volume);
Assert.AreEqual(5, closedOrders[0].VolumeExecuted);
Assert.AreEqual(0, closedOrders[0].OpenQuantity);
Assert.AreEqual("Market", closedOrders[0].Type);
Assert.AreEqual("Sell", closedOrders[0].Side);
Assert.AreEqual("Complete", closedOrders[0].Status);
//------------------- Closed Orders -------------------------
//------------------- Trades -------------------------
IHttpActionResult tradesResponse = GetTrades(tradeController);
OkNegotiatedContentResult <object> okTradeResponse = (OkNegotiatedContentResult <object>)tradesResponse;
IList <object> tradesintermediateList = (IList <object>)okTradeResponse.Content;
IList <object[]> trades = new List <object[]>();
for (int i = 0; i < tradesintermediateList.Count; i++)
{
object[] objects = tradesintermediateList[i] as object[];
trades.Add(objects);
}
// This call return list of object, so we have to explicitly check values within elements
Assert.AreEqual(252, trades[2][2]); // Price
Assert.AreEqual(3, trades[2][3]); // Volume
Assert.AreEqual("BTCLTC", trades[2][4]);
Assert.AreEqual(252, trades[1][2]);
Assert.AreEqual(2, trades[1][3]);
Assert.AreEqual("BTCLTC", trades[0][4]);
Assert.AreEqual(250, trades[0][2]);
Assert.AreEqual(5, trades[0][3]);
Assert.AreEqual("BTCLTC", trades[0][4]);
//------------------- Trades -------------------------
}
public void GetTradesForTraderBetweenTimeRangeTest_TestsTheMethodThatWillGetAllTradesForACurrencypair_AssertsTheValuesOfTheFetchedTrades()
{
// Get the context
IApplicationContext applicationContext = ContextRegistry.GetContext();
//Exchange exchange = new Exchange();
//IEventStore inputEventStore = new RavenNEventStore(Constants.INPUT_EVENT_STORE);
//IEventStore outputEventStore = new RavenNEventStore(Constants.OUTPUT_EVENT_STORE);
//Journaler inputJournaler = new Journaler(inputEventStore);
//Journaler outputJournaler = new Journaler(outputEventStore);
//InputDisruptorPublisher.InitializeDisruptor(new IEventHandler<InputPayload>[] { exchange, inputJournaler });
//OutputDisruptor.InitializeDisruptor(new IEventHandler<byte[]>[] { outputJournaler });
// Get the instance through Spring configuration
TradeController tradeController = (TradeController)applicationContext["TradeController"];
tradeController.Request = new HttpRequestMessage(HttpMethod.Post, "");
tradeController.Request.Headers.Add("Auth", "123456789");
// Get the instance through Spring configuration
OrderController orderController = (OrderController)applicationContext["OrderController"];
orderController.Request = new HttpRequestMessage(HttpMethod.Post, "");
orderController.Request.Headers.Add("Auth", "123456789");
ITradeRepository tradeRepository = (ITradeRepository)applicationContext["TradeRepository"];
ManualResetEvent manualResetEvent = new ManualResetEvent(false);
orderController.CreateOrder(new CreateOrderParam()
{
Pair = "BTCUSD",
Price = 491,
Volume = 100,
Side = "buy",
Type = "limit"
});
manualResetEvent.Reset();
manualResetEvent.WaitOne(2000);
orderController.CreateOrder(new CreateOrderParam()
{
Pair = "BTCUSD",
Price = 492,
Volume = 300,
Side = "buy",
Type = "limit"
});
manualResetEvent.Reset();
manualResetEvent.WaitOne(2000);
orderController.CreateOrder(new CreateOrderParam()
{
Pair = "BTCUSD",
Price = 493,
Volume = 1000,
Side = "buy",
Type = "limit"
});
orderController.CreateOrder(new CreateOrderParam()
{
Pair = "BTCUSD",
Price = 493,
Volume = 1000,
Side = "sell",
Type = "limit"
});
manualResetEvent.Reset();
manualResetEvent.WaitOne(2000);
orderController.CreateOrder(new CreateOrderParam()
{
Pair = "BTCUSD",
Price = 492,
Volume = 300,
Side = "sell",
Type = "limit"
});
manualResetEvent.Reset();
manualResetEvent.WaitOne(2000);
orderController.CreateOrder(new CreateOrderParam()
{
Pair = "BTCUSD",
Price = 491,
Volume = 100,
Side = "sell",
Type = "limit"
});
manualResetEvent.Reset();
manualResetEvent.WaitOne(4000);
IHttpActionResult httpActionResult = tradeController.GetTradeHistory(new TradeHistoryParams("2014/05/09", "2014/05/09"));
OkNegotiatedContentResult <object> okResponseObject = (OkNegotiatedContentResult <object>)httpActionResult;
IList <object> objectList = (IList <object>)okResponseObject.Content;
List <object[]> newObjectsList = new List <object[]>();
for (int i = 0; i < objectList.Count; i++)
{
object[] objects = objectList[i] as object[];
newObjectsList.Add(objects);
}
Assert.AreEqual(493, newObjectsList[0][2]);
Assert.AreEqual(1000, newObjectsList[0][3]);
Assert.AreEqual(492, newObjectsList[1][2]);
Assert.AreEqual(300, newObjectsList[1][3]);
Assert.AreEqual(491, newObjectsList[2][2]);
Assert.AreEqual(100, newObjectsList[2][3]);
InputDisruptorPublisher.Shutdown();
OutputDisruptor.ShutDown();
tradeRepository.RollBack();
}
public void GetTradeDetails_SendMatchingOrdersWithDifferentTraders_TradeDetailsShouldGetReceived()
{
// Get the context
IApplicationContext applicationContext = ContextRegistry.GetContext();
// Get the instance through Spring configuration
TradeController tradeController = (TradeController)applicationContext["TradeController"];
tradeController.Request = new HttpRequestMessage(HttpMethod.Post, "");
tradeController.Request.Headers.Add("Auth", "123456789");
// Get the instance through Spring configuration
OrderController orderController = (OrderController)applicationContext["OrderController"];
orderController.Request = new HttpRequestMessage(HttpMethod.Post, "");
orderController.Request.Headers.Add("Auth", "123456789");
ITradeRepository tradeRepository = (ITradeRepository)applicationContext["TradeRepository"];
ManualResetEvent manualResetEvent = new ManualResetEvent(false);
orderController.CreateOrder(new CreateOrderParam()
{
Pair = "BTCUSD",
Price = 491,
Volume = 100,
Side = "buy",
Type = "limit"
});
manualResetEvent.Reset();
manualResetEvent.WaitOne(2000);
OrderController orderController1 = (OrderController)applicationContext["OrderController"];
orderController1.Request = new HttpRequestMessage(HttpMethod.Post, "");
orderController1.Request.Headers.Add("Auth", "55555");
orderController1.CreateOrder(new CreateOrderParam()
{
Pair = "BTCUSD",
Price = 490,
Volume = 300,
Side = "sell",
Type = "limit"
});
manualResetEvent.Reset();
manualResetEvent.WaitOne(4000);
IHttpActionResult httpActionResult = tradeController.GetTradeHistory(new TradeHistoryParams("", ""));
OkNegotiatedContentResult <object> okResponseObject = (OkNegotiatedContentResult <object>)httpActionResult;
IList <object> objectList = (IList <object>)okResponseObject.Content;
object[] details = objectList[0] as object[];
string tradeId = details[0] as string;
//verify trader("123456789") details
httpActionResult = tradeController.TradeDetails(tradeId);
OkNegotiatedContentResult <TradeDetailsRepresentation> tradeDetails =
(OkNegotiatedContentResult <TradeDetailsRepresentation>)httpActionResult;
Assert.AreEqual(tradeDetails.Content.TradeId, tradeId);
Assert.AreEqual(tradeDetails.Content.ExecutionPrice, (decimal)details[2]);
Assert.AreEqual(tradeDetails.Content.Volume, (decimal)details[3]);
Assert.AreEqual(tradeDetails.Content.Order.Price, 491);
Assert.AreEqual(tradeDetails.Content.Order.Side, OrderSide.Buy.ToString());
Assert.AreEqual(tradeDetails.Content.Order.Type, OrderType.Limit.ToString());
Assert.AreEqual(tradeDetails.Content.Order.Volume, 100);
Assert.AreEqual(tradeDetails.Content.Order.Status, OrderState.Complete.ToString());
//verify trader("55555") details
TradeController tradeController1 = (TradeController)applicationContext["TradeController"];
tradeController1.Request = new HttpRequestMessage(HttpMethod.Post, "");
tradeController1.Request.Headers.Add("Auth", "55555");
httpActionResult = tradeController1.TradeDetails(tradeId);
OkNegotiatedContentResult <TradeDetailsRepresentation> tradeDetails1 =
(OkNegotiatedContentResult <TradeDetailsRepresentation>)httpActionResult;
Assert.AreEqual(tradeDetails1.Content.TradeId, tradeId);
Assert.AreEqual(tradeDetails1.Content.ExecutionPrice, (decimal)details[2]);
Assert.AreEqual(tradeDetails1.Content.Volume, (decimal)details[3]);
Assert.AreEqual(tradeDetails1.Content.Order.Price, 490);
Assert.AreEqual(tradeDetails1.Content.Order.Side, OrderSide.Sell.ToString());
Assert.AreEqual(tradeDetails1.Content.Order.Type, OrderType.Limit.ToString());
Assert.AreEqual(tradeDetails1.Content.Order.Volume, 300);
Assert.AreEqual(tradeDetails1.Content.Order.Status, OrderState.PartiallyFilled.ToString());
InputDisruptorPublisher.Shutdown();
OutputDisruptor.ShutDown();
tradeRepository.RollBack();
}
// Connectors calls -
public void OnPlayerFinished(Player sender, int turn, object move)
{
// Player <player> has ended their turn on their machine. End it locally as well.
// Start the turn for the next player only if there's players who haven't yet played it.
if (turnManager.IsCompletedByAll)
{
return;
}
Player nextPlayer;
int prevPlayerPosition = -1;
for (int i = 0; i < PhotonNetwork.PlayerList.Length; i++)
{
if (sender.ActorNumber == PhotonNetwork.PlayerList[i].ActorNumber)
{
prevPlayerPosition = i;
break;
}
}
if (PhotonNetwork.CurrentRoom.PlayerCount > 1)
{
if (currentTurn != 2)
{
nextPlayer = PhotonNetwork.PlayerList[prevPlayerPosition + 1];
}
else
{
// LIFO setup.
nextPlayer = PhotonNetwork.PlayerList[prevPlayerPosition - 1];
}
}
else
{
nextPlayer = null;
}
if (nextPlayer == null)
{
return;
}
this.currentPlayer = nextPlayer;
if (PhotonNetwork.LocalPlayer == nextPlayer)
{
currentTurn = turn;
if (turn == 1)
{
ClaimColour();
myTurn = true;
GameObject.Find("DiceController").GetComponent <DiceController>().SetDiceOwner(PhotonNetwork.LocalPlayer);
setUpPhase = true;
// Turns starts once a colour slot is claimed.
}
else if (turn == 2)
{
// Init trade.
tradeController = GameObject.Find("TradeController").GetComponent <TradeController>();
tradeController.Init(inventory);
myTurn = true;
audioSource.Play();
eventTextController.SetCurrentPlayer(PhotonNetwork.LocalPlayer);
GameObject.Find("DiceController").GetComponent <DiceController>().SetDiceOwner(PhotonNetwork.LocalPlayer);
}
else if (turn == 3)
{
setUpPhase = false;
currentPhase = Phase.ROLL_DICE;
myTurn = true;
audioSource.Play();
eventTextController.SetCurrentPlayer(PhotonNetwork.LocalPlayer);
GameObject.Find("DiceController").GetComponent <DiceController>().SetDiceOwner(PhotonNetwork.LocalPlayer);
}
else
{
myTurn = true;
audioSource.Play();
currentPhase = Phase.ROLL_DICE;
GameObject.Find("DiceController").GetComponent <DiceController>().SetDiceOwner(PhotonNetwork.LocalPlayer);
eventTextController.SetCurrentPlayer(PhotonNetwork.LocalPlayer);
}
}
}
// Called from TurnManager - Each player gets this called by their local turn manager
public void OnTurnBegins(int turn)
{
Debug.Log("Turn " + turn + " beginning globally.");
currentTurn = turn;
if (turn == 1)
{
currentPlayer = PhotonNetwork.PlayerList[0];
setUpPhase = true;
if (PhotonNetwork.LocalPlayer == currentPlayer)
{
// Claim colour slot.
ClaimColour();
myTurn = true;
GameObject.Find("DiceController").GetComponent <DiceController>().SetDiceOwner(PhotonNetwork.LocalPlayer);
// Turns starts once a colour slot is claimed.
}
}
else if (turn == 2)
{
currentPlayer = PhotonNetwork.PlayerList[PhotonNetwork.PlayerList.Length - 1];
if (PhotonNetwork.LocalPlayer == currentPlayer)
{
// Init trade.
tradeController = GameObject.Find("TradeController").GetComponent <TradeController>();
tradeController.Init(inventory);
Debug.Log("In turn2 the player to play is: " + PhotonNetwork.LocalPlayer.ActorNumber + ", name = " + PhotonNetwork.LocalPlayer.NickName);
myTurn = true;
audioSource.Play();
eventTextController.SetCurrentPlayer(PhotonNetwork.LocalPlayer);
GameObject.Find("DiceController").GetComponent <DiceController>().SetDiceOwner(PhotonNetwork.LocalPlayer);
}
}
else if (turn == 3)
{
currentPlayer = PhotonNetwork.PlayerList[0];
if (PhotonNetwork.LocalPlayer == currentPlayer)
{
myTurn = true;
audioSource.Play();
setUpPhase = false;
currentPhase = Phase.ROLL_DICE;
eventTextController.SetCurrentPlayer(PhotonNetwork.LocalPlayer);
GameObject.Find("DiceController").GetComponent <DiceController>().SetDiceOwner(PhotonNetwork.LocalPlayer);
}
}
else
{
currentPlayer = PhotonNetwork.PlayerList[0];
if (PhotonNetwork.LocalPlayer == currentPlayer)
{
Debug.Log("In turn" + turn + " the player to play is: " + PhotonNetwork.LocalPlayer.ActorNumber + ", name = " + PhotonNetwork.LocalPlayer.NickName);
myTurn = true;
audioSource.Play();
currentPhase = Phase.ROLL_DICE;
eventTextController.SetCurrentPlayer(PhotonNetwork.LocalPlayer);
GameObject.Find("DiceController").GetComponent <DiceController>().SetDiceOwner(PhotonNetwork.LocalPlayer);
}
}
}
public TradeControllerTests()
{
_tradeController = new TradeController(_shareRepositoryMock.Object, _tradeRepositoryMock.Object, _portfolioRepositoryMock.Object);
//(IShareRepository shareRepository, ITradeRepository tradeRepository, IPortfolioRepository portfolioRepository)
}
public TradeControllerTests()
{
_tradeController = new TradeController(_tradeService.Object);
}
public void Start()
{
// Create GameObject so we can have access to a transform which has a position of "Vector3.zero".
new GameObject("VisualPath", typeof(VisualPath));
GameObject go;
tileSpriteController = new TileSpriteController(World);
characterSpriteController = new CharacterSpriteController(World);
furnitureSpriteController = new FurnitureSpriteController(World);
utilitySpriteController = new UtilitySpriteController(World);
jobSpriteController = new JobSpriteController(World, furnitureSpriteController, utilitySpriteController);
inventorySpriteController = new InventorySpriteController(World, inventoryUI);
shipSpriteController = new ShipSpriteController(World);
buildModeController = new BuildModeController();
spawnInventoryController = new SpawnInventoryController();
mouseController = new MouseController(buildModeController, furnitureSpriteController, utilitySpriteController, circleCursorPrefab);
questController = new QuestController();
cameraController = new CameraController();
TradeController = new TradeController();
autosaveManager = new AutosaveManager();
// Register inputs actions
KeyboardManager.Instance.RegisterInputAction("DevMode", KeyboardMappedInputType.KeyDown, ChangeDevMode);
// Hiding Dev Mode spawn inventory controller if devmode is off.
spawnInventoryController.SetUIVisibility(SettingsKeyHolder.DeveloperMode);
cameraController.Initialize();
// Initialising controllers.
GameObject canvas = GameObject.Find("Canvas");
go = Instantiate(Resources.Load("UI/ContextMenu"), canvas.transform.position, canvas.transform.rotation, canvas.transform) as GameObject;
go.name = "ContextMenu";
GameObject timeScale = Instantiate(Resources.Load("UI/TimeScale"), GameObject.Find("TopRight").transform, false) as GameObject;
timeScale.name = "TimeScale";
GameObject dateTimeDisplay = Instantiate(Resources.Load("UI/DateTimeDisplay"), canvas.transform, false) as GameObject;
dateTimeDisplay.name = "DateTimeDisplay";
GameController.Instance.IsModal = false;
// Settings UI is a 'dialog box' (kinda), so it comes here.
// Where as DevConsole is a constant menu item (it can appear 'anywhere' so it appears after)
GameObject settingsMenu = (GameObject)Instantiate(Resources.Load("UI/SettingsMenu/SettingsMenu"));
if (settingsMenu != null)
{
settingsMenu.name = "Settings Menu";
settingsMenu.transform.SetParent(canvas.transform, false);
settingsMenu.SetActive(true);
}
// This will place it after context menu (and the inventory menu) and settings menu
dialogBoxManager = GameObject.Find("Dialog Boxes").GetComponent <DialogBoxManager>();
dialogBoxManager.transform.SetAsLastSibling();
GameObject devConsole = (GameObject)Instantiate(Resources.Load("UI/Console/DevConsole"));
if (devConsole != null)
{
devConsole.name = "DevConsole-Spawned";
devConsole.transform.SetParent(canvas.transform, false);
devConsole.transform.SetAsLastSibling();
devConsole.SetActive(true);
DeveloperConsole.DevConsole.Close();
}
}
public void Scenario3Test_TestsScenario3AndItsOutcome_VerifiesThroughMarketDataOrderAndTradesResults()
{
// Get the context
IApplicationContext applicationContext = ContextRegistry.GetContext();
// Get the instance through Spring configuration
OrderController orderController = (OrderController)applicationContext["OrderController"];
TradeController tradeController = (TradeController)applicationContext["TradeController"];
MarketController marketController = (MarketController)applicationContext["MarketController"];
orderController.Request = new HttpRequestMessage(HttpMethod.Post, "");
orderController.Request.Headers.Add("Auth", "123456789");
tradeController.Request = new HttpRequestMessage(HttpMethod.Post, "");
tradeController.Request.Headers.Add("Auth", "123456789");
marketController.Request = new HttpRequestMessage(HttpMethod.Post, "");
marketController.Request.Headers.Add("Auth", "123456789");
Scenario3OrderCreation(orderController);
// ------------------------------- Order Book ------------------------------
IHttpActionResult orderBookResponse = marketController.GetOrderBook("BTCLTC");
OkNegotiatedContentResult <object> okOrderBookResponse =
(OkNegotiatedContentResult <object>)orderBookResponse;
OrderBookRepresentation representation = okOrderBookResponse.Content as OrderBookRepresentation;
Tuple <OrderRepresentationList, OrderRepresentationList> orderBook = new Tuple <OrderRepresentationList, OrderRepresentationList>(representation.Bids, representation.Asks);
// Item1 = Bid Book, Item1[i].Item1 = Volume of 'i' Bid, Item1[i].Item2 = Price of 'i' Bid
Assert.AreEqual(0, orderBook.Item1.Count());
// Item2 = Bid Book, Item2[i].Item1 = Volume of Ask at index 'i', Item2[i].Item2 = Price of Bid at index 'i'
Assert.AreEqual(0, orderBook.Item2.Count());
// ------------------------------------------------------------------------
// --------------------------------- Depth ---------------------------------
IHttpActionResult depthResponse = marketController.GetDepth("BTCLTC");
OkNegotiatedContentResult <object> okDepth
= (OkNegotiatedContentResult <object>)depthResponse;
DepthTupleRepresentation depth = okDepth.Content as DepthTupleRepresentation;
// Item1 = Bid Book, Item1.Item1 = Aggregated Volume, Item1.Item2 = Price, Item1.Item3 = Number of Orders
Assert.IsNull(depth.BidDepth[0]);
Assert.IsNull(depth.BidDepth[1]);
Assert.IsNull(depth.BidDepth[2]);
Assert.IsNull(depth.BidDepth[3]);
Assert.IsNull(depth.BidDepth[4]);
// Item2 = Bid Book, Item2.Item1 = Aggregated Volume, Item2.Item2 = Price, Item2.Item3 = Number of Orders
Assert.IsNull(depth.AskDepth[0]);
Assert.IsNull(depth.AskDepth[1]);
Assert.IsNull(depth.AskDepth[2]);
Assert.IsNull(depth.AskDepth[3]);
Assert.IsNull(depth.AskDepth[4]);
// -----------------------------------------------------------------------
//------------------------- Open Orders ----------------------------------
IHttpActionResult openOrdersResponse = GetOpenOrders(orderController);
OkNegotiatedContentResult <List <OrderReadModel> > okOpenOrdersResponse = (OkNegotiatedContentResult <List <OrderReadModel> >)openOrdersResponse;
List <OrderReadModel> openOrders = okOpenOrdersResponse.Content;
Assert.AreEqual(0, openOrders.Count);
//---------------------------------------------------------------------
//-------------------------- Closed Orders ----------------------------
IHttpActionResult closedOrdersResponse = GetClosedOrders(orderController);
OkNegotiatedContentResult <List <OrderReadModel> > okClosedOrdersResponse = (OkNegotiatedContentResult <List <OrderReadModel> >)closedOrdersResponse;
List <OrderReadModel> closedOrders = okClosedOrdersResponse.Content;
// Order List comes in descending order, so asserts are placed that way too
Assert.AreEqual(252, closedOrders[8].Price);
Assert.AreEqual(5, closedOrders[8].Volume);
Assert.AreEqual(0, closedOrders[8].VolumeExecuted);
Assert.AreEqual(5, closedOrders[8].OpenQuantity);
Assert.AreEqual("Limit", closedOrders[8].Type);
Assert.AreEqual("Sell", closedOrders[8].Side);
Assert.AreEqual("Cancelled", closedOrders[8].Status);
Assert.AreEqual(245, closedOrders[7].Price);
Assert.AreEqual(8, closedOrders[7].Volume);
Assert.AreEqual(0, closedOrders[7].VolumeExecuted);
Assert.AreEqual(8, closedOrders[7].OpenQuantity);
Assert.AreEqual("Limit", closedOrders[7].Type);
Assert.AreEqual("Buy", closedOrders[7].Side);
Assert.AreEqual("Cancelled", closedOrders[7].Status);
Assert.AreEqual(250, closedOrders[6].Price);
Assert.AreEqual(7, closedOrders[6].Volume);
Assert.AreEqual(7, closedOrders[6].VolumeExecuted);
Assert.AreEqual(0, closedOrders[6].OpenQuantity);
Assert.AreEqual("Limit", closedOrders[6].Type);
Assert.AreEqual("Buy", closedOrders[6].Side);
Assert.AreEqual("Complete", closedOrders[6].Status);
Assert.AreEqual(250, closedOrders[5].Price);
Assert.AreEqual(3, closedOrders[5].Volume);
Assert.AreEqual(2, closedOrders[5].VolumeExecuted);
Assert.AreEqual(1, closedOrders[5].OpenQuantity);
Assert.AreEqual("Limit", closedOrders[5].Type);
Assert.AreEqual("Buy", closedOrders[5].Side);
Assert.AreEqual("Cancelled", closedOrders[5].Status);
Assert.AreEqual(253, closedOrders[4].Price);
Assert.AreEqual(5, closedOrders[4].Volume);
Assert.AreEqual(0, closedOrders[4].VolumeExecuted);
Assert.AreEqual(5, closedOrders[4].OpenQuantity);
Assert.AreEqual("Limit", closedOrders[4].Type);
Assert.AreEqual("Sell", closedOrders[4].Side);
Assert.AreEqual("Cancelled", closedOrders[4].Status);
Assert.AreEqual(240, closedOrders[3].Price);
Assert.AreEqual(8, closedOrders[3].Volume);
Assert.AreEqual(0, closedOrders[3].VolumeExecuted);
Assert.AreEqual(8, closedOrders[3].OpenQuantity);
Assert.AreEqual("Limit", closedOrders[3].Type);
Assert.AreEqual("Buy", closedOrders[3].Side);
Assert.AreEqual("Cancelled", closedOrders[3].Status);
Assert.AreEqual(245, closedOrders[2].Price);
Assert.AreEqual(7, closedOrders[2].Volume);
Assert.AreEqual(0, closedOrders[2].VolumeExecuted);
Assert.AreEqual(7, closedOrders[2].OpenQuantity);
Assert.AreEqual("Limit", closedOrders[2].Type);
Assert.AreEqual("Buy", closedOrders[2].Side);
Assert.AreEqual("Cancelled", closedOrders[2].Status);
Assert.AreEqual(247, closedOrders[1].Price);
Assert.AreEqual(3, closedOrders[1].Volume);
Assert.AreEqual(0, closedOrders[1].VolumeExecuted);
Assert.AreEqual(3, closedOrders[1].OpenQuantity);
Assert.AreEqual("Limit", closedOrders[1].Type);
Assert.AreEqual("Buy", closedOrders[1].Side);
Assert.AreEqual("Cancelled", closedOrders[1].Status);
Assert.AreEqual(0, closedOrders[0].Price);
Assert.AreEqual(9, closedOrders[0].Volume);
Assert.AreEqual(9, closedOrders[0].VolumeExecuted);
Assert.AreEqual(0, closedOrders[0].OpenQuantity);
Assert.AreEqual("Market", closedOrders[0].Type);
Assert.AreEqual("Sell", closedOrders[0].Side);
Assert.AreEqual("Complete", closedOrders[0].Status);
//------------------------------------------------------------------------
//------------------- Trades -------------------------
IHttpActionResult tradesResponse = GetTrades(tradeController);
OkNegotiatedContentResult <object> okTradeResponse = (OkNegotiatedContentResult <object>)tradesResponse;
IList <object> tradesintermediateList = (IList <object>)okTradeResponse.Content;
IList <object[]> trades = new List <object[]>();
for (int i = 0; i < tradesintermediateList.Count; i++)
{
object[] objects = tradesintermediateList[i] as object[];
trades.Add(objects);
}
// These trades execute simultaneously, so when queried from the database and sorted as per the time when
// they were saved in the database, they can be queried out of the order as we expected because they have the
// same time. So we check if one trade came before the other and place assertions for it then for the other and
// vice versa
if ((decimal)trades[1][3] == 7)
{
Assert.AreEqual(250, trades[1][2]); // Price
Assert.AreEqual(7, trades[1][3]); // Volume
Assert.AreEqual("BTCLTC", trades[1][4]); // CurrencyPair
}
else if ((decimal)trades[1][3] == 2)
{
Assert.AreEqual(250, trades[1][2]);
Assert.AreEqual(2, trades[1][3]);
Assert.AreEqual("BTCLTC", trades[1][4]);
}
else
{
throw new Exception("No assertions could be made on expected trade");
}
if ((decimal)trades[0][3] == 7)
{
Assert.AreEqual(250, trades[0][2]); // Price
Assert.AreEqual(7, trades[0][3]); // Volume
Assert.AreEqual("BTCLTC", trades[0][4]); // CurrencyPair
}
else if ((decimal)trades[0][3] == 2)
{
Assert.AreEqual(250, trades[0][2]); // Price
Assert.AreEqual(2, trades[0][3]); // Volume
Assert.AreEqual("BTCLTC", trades[0][4]); // CurrencyPair
}
else
{
throw new Exception("No assertions could be made on expected trade");
}
//-----------------------------------------------------------------------
}
public TradeControllerTests() : base()
{
_tradeController = new TradeController(_shareRepository, _tradeRepository, _portfolioRepository);
}
/// <summary>
/// Get Trades
/// </summary>
/// <param name="tradeController"></param>
/// <returns></returns>
private dynamic GetTrades(TradeController tradeController)
{
return(tradeController.GetTradeHistory(new TradeHistoryParams("", "")));
}
public void SetUp()
{
_tradeService = new Mock <ITradeService>();
_tradeController = new TradeController(_tradeService.Object);
}
private void InitTradeController(XElement controllerNode, EventBus eventBus, string workingDirectory)
{
var updatePeriod = (int)controllerNode.Descendants("UpdatePeriod").Single();
var serverCooldownPeriod = (int)controllerNode.Descendants("ServerCooldownPeriod").Single();
var tradeStartTime = (TimeSpan)controllerNode.Descendants("TradeStartTime").Single();
TradeController = new TradeController(eventBus, Connector, RobotContext, workingDirectory, updatePeriod, serverCooldownPeriod, tradeStartTime);
}
