/// <summary>
/// Place a paper trade for testing purposes
/// </summary>
/// <param name="tradeParams">Trade parameters</param>
/// <returns>TradeResponse object</returns>
private TradeResponse PlacePaperTrade(TradeParams tradeParams)
{
OrderType orderType;
TimeInForce TIF;
TradeType tradeType;
Enum.TryParse(tradeParams.type, out orderType);
Enum.TryParse(tradeParams.timeInForce, out TIF);
Enum.TryParse(tradeParams.side, out tradeType);
var response = new TradeResponse
{
clientOrderId = $"PaperTrade_{tradeNumber}",
executedQty = tradeParams.quantity,
orderId = tradeNumber,
origQty = tradeParams.quantity,
price = tradeParams.price,
side = tradeType,
status = OrderStatus.FILLED,
symbol = tradeParams.symbol,
timeInForce = TIF,
transactTime = _dtHelper.UTCtoUnixTime(),
type = orderType
};
return(response);
}
public void NotifyTradeResponseApproved(TradeResponse response)
{
string message = string.Format(@"
<div style = ""font-family:Verdana, Geneva, sans-serif; margin: auto; width: 50%; "">
<h3 style=""text-align: center;"">Uw reactie werd goedgekeurd</h3>
<p>Beste {0},</br>
</br>
<p>Uw reactie op de aanbieding van {1} werd door hun goedgekeurd.</p>
<p>Om uw tickets te ontvangen moet u nogmaals op ""Akkoord"" klikken op <a href=""http://new.massacantusgent.be/tickets/closetrade/{2}"">deze pagina</a>.</p>
<br />
<p>Klopt er volgens u niet? Gelieve dan contact op te nemen met [email protected]</p>
<p>Vriendelijke groeten,</br>
Het Massacantuscomité</p>
</div>
",
response.Vereniging.GroepNaam,
response.Offer.Owner.GroepNaam,
response.Id);
_mailSender.SendMCEmailAsync(
response.Vereniging.Email,
$"Uw reactie op de aanbieding van {response.Offer.Owner.GroepNaam} werd goedgekeurd - Massacantus Gent",
message,
response.Vereniging.GroepNaam
);
}
private static void WebSocketTableMessage(object sender, TradeResponse e)
{
foreach (var trade in e.Data)
{
System.Console.WriteLine("[Web Socket: New trade] {0} {1} {2} for price: {3}", trade.Side, trade.Size, trade.Symbol, trade.Price);
}
}
private bool HandleObjectMessage(string msg)
{
// ********************
// ADD OBJECT HANDLERS BELOW
// ********************
return
(ErrorResponse.TryHandle(msg, Streams.ErrorSubject) ||
SubscribeResponse.TryHandle(msg, Streams.SubscribeSubject) ||
BookResponse.TryHandle(msg, Streams.BookSubject) ||
TradeResponse.TryHandle(msg, Streams.TradesSubject) ||
QuoteResponse.TryHandle(msg, Streams.QuoteSubject) ||
LiquidationResponse.TryHandle(msg, Streams.LiquidationSubject) ||
PositionResponse.TryHandle(msg, Streams.PositionSubject) ||
MarginResponse.TryHandle(msg, Streams.MarginSubject) ||
OrderResponse.TryHandle(msg, Streams.OrderSubject) ||
WalletResponse.TryHandle(msg, Streams.WalletSubject) ||
ExecutionResponse.TryHandle(msg, Streams.ExecutionSubject) ||
FundingResponse.TryHandle(msg, Streams.FundingsSubject) ||
InstrumentResponse.TryHandle(msg, Streams.InstrumentSubject) ||
TradeBinResponse.TryHandle(msg, Streams.TradeBinSubject) ||
InfoResponse.TryHandle(msg, Streams.InfoSubject) ||
AuthenticationResponse.TryHandle(msg, Streams.AuthenticationSubject));
}
public IActionResult ApproveTradeResponseByOwnerConfirmation(int id)
{
McEditie editie = _editieRepository.GetNextOrCurrentEditieIncludeTrades();
if (editie == null)
{
return(NotFound("Er is nog geen opkomende editie aangemaakt, als dit volgens u niet klopt, gelieve dan contact op te nemen met [email protected]"));
}
TradeResponse response = editie.GetTradeResponseById(id);
if (response != null)
{
try
{
response.Offer.ApproveResponse(response.Id);
_editieRepository.SaveChanges();
NotifyTradeResponseApproved(response);
TempData["message"] = $"U heeft succesvol de reactie van {response.Vereniging.GroepNaam} goedgekeurd!";
}
catch (Exception ex)
{
TempData["error"] = $"Er ging iets mis: {ex.Message}";
}
}
return(RedirectToAction(nameof(Doorverkoop)));
}
/// <summary>
/// Handles object messages sent by bitmex.
/// </summary>
/// <param name="msg">The MSG.</param>
/// <param name="streams">The streams.</param>
/// <returns></returns>
public static bool HandleObjectMessage(string msg, BitmexClientStreams streams)
{
var response = BitmexJsonSerializer.Deserialize <JObject>(msg);
// ********************
// ADD OBJECT HANDLERS BELOW
// ********************
return
(TradeResponse.TryHandle(response, streams.TradesSubject) ||
TradeBinResponse.TryHandle(response, streams.TradeBinSubject) ||
BookResponse.TryHandle(response, streams.BookSubject) ||
QuoteResponse.TryHandle(response, streams.QuoteSubject) ||
LiquidationResponse.TryHandle(response, streams.LiquidationSubject) ||
PositionResponse.TryHandle(response, streams.PositionSubject) ||
MarginResponse.TryHandle(response, streams.MarginSubject) ||
OrderResponse.TryHandle(response, streams.OrderSubject) ||
WalletResponse.TryHandle(response, streams.WalletSubject) ||
InstrumentResponse.TryHandle(response, streams.InstrumentSubject) ||
ExecutionResponse.TryHandle(response, streams.ExecutionSubject) ||
FundingResponse.TryHandle(response, streams.FundingsSubject) ||
ErrorResponse.TryHandle(response, streams.ErrorSubject) ||
SubscribeResponse.TryHandle(response, streams.SubscribeSubject) ||
InfoResponse.TryHandle(response, streams.InfoSubject) ||
AuthenticationResponse.TryHandle(response, streams.AuthenticationSubject));
}
public void UpdateTrade(TradeResponse tradeResponse)
{
if (stockForm != null)
{
stockForm.UpdateTrade(tradeResponse);
}
}
private bool HandleObjectMessage(string msg)
{
var response = BitmexJsonSerializer.Deserialize <JObject>(msg);
// ********************
// ADD OBJECT HANDLERS BELOW
// ********************
return
(TradeResponse.TryHandle(response, Streams.TradesSubject) ||
TradeBinResponse.TryHandle(response, Streams.TradeBinSubject) ||
BookResponse.TryHandle(response, Streams.BookSubject) ||
QuoteResponse.TryHandle(response, Streams.QuoteSubject) ||
LiquidationResponse.TryHandle(response, Streams.LiquidationSubject) ||
PositionResponse.TryHandle(response, Streams.PositionSubject) ||
OrderResponse.TryHandle(response, Streams.OrderSubject) ||
WalletResponse.TryHandle(response, Streams.WalletSubject) ||
ErrorResponse.TryHandle(response, Streams.ErrorSubject) ||
SubscribeResponse.TryHandle(response, Streams.SubscribeSubject) ||
InfoResponse.TryHandle(response, Streams.InfoSubject) ||
AuthenticationResponse.TryHandle(response, Streams.AuthenticationSubject));
}
/// <summary>
/// Gets the text that your advisor will tell the player when they believe the response
/// to the trade proposal will be that which is passed in.
/// </summary>
/// <param name="response">The response to get the advisor text for.</param>
/// <returns>The text for the advisors' phrase telling you of the probable response from
/// the foreign country to the proposed trade.</returns>
public static string GetProbableTradeResponseString(TradeResponse response)
{
string text = string.Empty;
switch (response)
{
case TradeResponse.Accept:
text = ClientResources.GetString(StringKey.AdviseOfDealAcceptance);
break;
case TradeResponse.NeutralDecline:
text = ClientResources.GetString(StringKey.AdviseOfDealRejectionNeutral);
break;
case TradeResponse.StrongDecline:
text = ClientResources.GetString(StringKey.AdviseOfDealRejectionStrong);
break;
case TradeResponse.TotalDecline:
text = ClientResources.GetString(StringKey.AdviseOfDealRejectTotal);
break;
case TradeResponse.WeakDecline:
text = ClientResources.GetString(StringKey.AdviseOfDealRejectionWeak);
break;
}
return(text);
}
void _client_NewTradesEvent(TradeResponse trades)
{
lock (_newTradesLoker)
{
if (trades.data == null)
{
return;
}
Trade trade = new Trade();
trade.SecurityNameCode = trades.stream.ToString().ToUpper().Split('@')[0];
if (trade.SecurityNameCode != trades.data.s)
{
return;
}
trade.Price =
trades.data.p.ToDecimal();
trade.Id = trades.data.t.ToString();
trade.Time = new DateTime(1970, 1, 1).AddMilliseconds(Convert.ToDouble(trades.data.T));
trade.Volume =
trades.data.q.ToDecimal();
trade.Side = trades.data.m == true ? Side.Sell : Side.Buy;
if (NewTradesEvent != null)
{
NewTradesEvent(trade);
}
}
}
public async Task Connect_ShouldWorkAndReceiveResponse()
{
var url = BinanceValues.ApiWebsocketUrl;
using (var communicator = new BinanceWebsocketCommunicator(url))
{
TradeResponse received = null;
var receivedEvent = new ManualResetEvent(false);
using (var client = new BinanceWebsocketClient(communicator))
{
client.Streams.TradesStream.Subscribe(response =>
{
received = response;
receivedEvent.Set();
});
client.SetSubscriptions(
new TradeSubscription("btcusdt")
);
await communicator.Start();
receivedEvent.WaitOne(TimeSpan.FromSeconds(30));
Assert.NotNull(received);
}
}
}
/// <summary>
/// Get Order Details
/// </summary>
/// <param name="trade">TradeResponse object</param>
/// <param name="symbol">Trading symbol</param>
/// <returns>OrderResponse object</returns>
public OrderResponse GetOrderDetail(TradeResponse trade, string symbol = "")
{
if (_thisExchange == Exchange.BINANCE)
{
var response = _bianceRepo.GetOrder(symbol, trade.orderId).Result;
return(response);
}
else if (_thisExchange == Exchange.GDAX)
{
var response = _gdaxRepo.GetRestOrder(trade.clientOrderId).Result;
return(response == null ? null : GdaxOrderResponseToOrderResponse(response));
}
else if (_thisExchange == Exchange.KUCOIN)
{
var response = _kuRepo.GetOrder(trade.symbol, trade.side, trade.orderId).Result;
return(response == null ? null : KuCoinOrderListDetailToOrderResponse(response, trade.symbol));
}
else
{
return(null);
}
}
private void HandleTradeResponse(TradeResponse obj)
{
_logger.LogInformation("HandleTradeResponse Message={0}", obj);
if (OnTradeResponse != null)
{
OnTradeResponse(obj);
}
}
public void UpdateTrade(TradeResponse trade)
{
Invoke(new MethodInvoker(
delegate
{
tradeRequestStatusTextBox.Text = "Confirmed. " + trade.Ticker + " " + trade.Price;
}));
}
public CloseTradeModel(McEditie editie, TradeResponse response)
{
VerenigingNaam = response.Offer.Owner.GroepNaam;
Amount = response.Amount;
Price = response.Amount * editie.TicketPrijs;
ResponseId = response.Id;
OfferId = response.Offer.Id;
}
public ApproveTradeOwnerModel(TradeResponse response, McEditie editie)
{
Amount = response.Amount;
VerenigingNaam = response.Vereniging.GroepNaam;
VerenigingMail = response.Vereniging.Email;
ResponseId = response.Id;
Price = Amount * editie.TicketPrijs;
}
protected virtual void OnNewTradeMessage(TradeResponse e)
{
var handler = NewTradeMessage;
if (handler != null)
{
handler(this, e);
}
}
private Trade ParseTrade(TradeResponse response)
{
return(new Trade(
response.Tid,
response.Price,
response.Amount,
response.Type == 1,
response.Date.ToDateTimeFromSeconds()));
}
private static Trade ParseTrade(TradeResponse response)
{
return(new Trade(
response.Id,
response.Price,
float.Parse(response.Qty, CultureInfo.InvariantCulture),
response.IsBuyerMaker,
response.Time.ToDateTimeFromMilliseconds()));
}
/// <summary>
/// Retrieves the details for a given trade
/// </summary>
/// <param name="accountId">the account to which the trade belongs</param>
/// <param name="tradeId">the ID of the trade to get the details</param>
/// <returns>TradeData object containing the details of the trade</returns>
public static async Task <Trade> GetTradeDetailsAsync(string accountId, long tradeId)
{
string requestString = Server(EServer.Account) + "accounts/" + accountId + "/trades/" + tradeId;
TradeResponse tradeResponse = await MakeRequestAsync <TradeResponse>(requestString);
var trade = tradeResponse.trade;
return(trade);
}
private static void MyCustomCallback(MessageType messageType, string data)
{
// this is our custom callback we can do whatever we want with the data here
OutputConsole.WriteLine($"{DateTime.UtcNow}: Received {messageType} message in private channel callback", ConsoleColor.Green);
switch (messageType)
{
// if you want to deserialize into one of the premade classes you can do so quite easily by checking the MessageType and deserializing into the apropriate response class
case MessageType.TradeData:
try
{
var deserializedClass = TradeResponse.FromJson(_client.Options.Serializer, data);
OutputConsole.WriteLine($"{DateTime.UtcNow}: We have deserialized a trade in our custom callback and the price in that trade is {deserializedClass.TradeData.Trade.Price}", ConsoleColor.Green);
}
catch (Exception ex)
{
OutputConsole.WriteLine(ex.Message);
}
break;
case MessageType.OrderData:
try
{
var deserializedClass = OrderResponse.FromJson(_client.Options.Serializer, data);
OutputConsole.WriteLine($"{DateTime.UtcNow}: We have deserialized an orderbook in our custom callback and the first price in that data is {deserializedClass.OrderData.Orders[0].Price}", ConsoleColor.Green);
}
catch (Exception ex)
{
OutputConsole.WriteLine(ex.Message);
}
break;
case MessageType.NewsData:
break;
case MessageType.BlockData:
break;
case MessageType.FavoriteData:
break;
case MessageType.NewMarket:
break;
case MessageType.NotificationData:
break;
case MessageType.Unknown:
break;
default:
throw new ArgumentOutOfRangeException(nameof(messageType), messageType, null);
}
}
public async Task TradeAsync(TradeRequest request, Func <TradeResponse, Task> responseHandler)
{
_logger.LogInformation("Trade {}", request);
var resp = new TradeResponse()
{
RequestId = request.RequestId
};
try
{
if (!await AcquireGameLock(request.GameId, request.RequestId, TimeSpan.FromSeconds(30)))
{
resp.ErrorMessage = "Timed out while acquiring game lock";
await responseHandler(resp);
return;
}
var gameState = await _dbContext.GameStates
.FirstOrDefaultAsync(x => x.GameId == request.GameId);
if (gameState == null)
{
resp.ErrorMessage = "GameId not found";
await responseHandler(resp);
return;
}
var gameEngine = new GameEngine(_loggerProvider, _dbContext, _cardRepo);
gameEngine.GameState = gameState;
if (gameEngine.GameState.IsFinished)
{
resp.ErrorMessage = "Game is finished";
await responseHandler(resp);
return;
}
List <Models.Trade> trades;
(resp.IsSuccess, resp.ErrorMessage, trades) = await gameEngine.Trade(request);
await responseHandler(resp);
if (resp.IsSuccess)
{
InvokeOnGameUpdate(MakeGameUpdateResponse(gameEngine.GameState));
InvokeOnTradeUpdate(null, MakeTradeUpdateResponse(gameEngine.GameState.GameId, trades));
}
}
finally
{
ReleaseGameLock(request.GameId, request.RequestId);
}
}
/// <summary>
/// Convert GDAX CancelOrderResponse to TradeResponse
/// </summary>
/// <param name="response">GDAX CancelOrderResponse object</param>
/// <returns>TradeReponse object</returns>
private TradeResponse GdaxCancelOrderResponseToTradeResponse(GDAXSharp.Services.Orders.Models.Responses.CancelOrderResponse response)
{
var tradeResponse = new TradeResponse
{
clientOrderId = response.OrderIds.First().ToString(),
transactTime = _dtHelper.UTCtoUnixTime()
};
return(tradeResponse);
}
public TradeResponse ExecuteTradeRequest(TradeRequest request)
{
TradeResponse response = new TradeResponse();
response.OrderType = request.OrderType;
response.Price = CalculatePrice(request.Ticker, request.Quantity, request.OrderType, request.Price, request.UserName);
response.Quantity = request.Quantity;
response.Ticker = request.Ticker;
response.ConfirmationNumber = new Guid().ToString();
return(response);
}
private void HandleTradeSafe(TradeResponse response)
{
try
{
HandleTrade(response);
}
catch (Exception e)
{
Log.Error(e, $"[Coinbase] Failed to handle trade info, error: '{e.Message}'");
}
}
public bool Equals(TradeResponse other)
{
if (ReferenceEquals(null, other))
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return(Equals(other.ticker, ticker) && other.quantity == quantity && other.price == price && Equals(other.orderType, orderType) && Equals(other.confirmationNumber, confirmationNumber) && other.error.Equals(error) && Equals(other.errorMessage, errorMessage));
}
//id = responseId
public IActionResult DeclineTradeResponse(int id)
{
McEditie editie = _editieRepository.GetNextOrCurrentEditieIncludeTrades();
if (editie == null)
{
return(NotFound("Er is nog geen opkomende editie aangemaakt, als dit volgens u niet klopt, gelieve dan contact op te nemen met [email protected]"));
}
TradeResponse response = editie.GetTradeResponseById(id);
return(View(response));
}
private static void MyCustomCallback(MessageType messageType, string data)
{
// this is our custom callback we can do whatever we want with the data here
OutputConsole.WriteLine($"{DateTime.UtcNow}: Received {messageType} message in private channel callback", ConsoleColor.Green);
// if you want to deserialize into one of thhe premade classes you can do so quite easily by checking the MessageType and deserializing into the apropriate response class
if (messageType == MessageType.TradeData)
{
var deserializedClass = TradeResponse.FromJson(data);
OutputConsole.WriteLine($"{DateTime.UtcNow}: We have deserialized a trade in our custom callbeck and the price in that trade is {deserializedClass.TradeData.Trade.Price}", ConsoleColor.Green);
}
}
private void HandleTradeResponse(TradeResponse obj)
{
if (!obj.IsSuccess)
{
InvokeStateChanged(new GameAlertEventArgs()
{
IsModal = true,
IsError = true,
Title = "Failed to Initate Trade",
Message = $"Error: {obj.ErrorMessage}"
});
}
}
public void PressAccept()
{
if (GameManager.Instance.gameState.gold >= this.goldCostToTrade)
{
this.tradeResponse = TradeResponse.YES;
}
else
{
this.tradeResponse = TradeResponse.NOT_ENOUGH_MONEY;
}
this.responseReceived = true;
}
public bool Equals(TradeResponse other)
{
if (ReferenceEquals(null, other)) return false;
if (ReferenceEquals(this, other)) return true;
return Equals(other.ticker, ticker) && other.quantity == quantity && other.price == price && Equals(other.orderType, orderType) && Equals(other.confirmationNumber, confirmationNumber) && other.error.Equals(error) && Equals(other.errorMessage, errorMessage);
}
