/// <summary>
/// Lurkers the new offer.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The trade event.</param>
private void Lurker_IncomingOffer(object sender, TradeEvent e)
{
if (this.TradeOffers.Any(o => o.Event.Equals(e)))
{
return;
}
if (this._settingsService.AlertEnabled)
{
this.PlayAlert();
}
Execute.OnUIThread(() =>
{
this.TradeOffers.Add(new OfferViewModel(e, this._keyboardHelper, this._context, this._settingsService, this.CheckIfOfferIsAlreadySold(e)));
});
}
private void FireOnUserAddItem(TradeEvent tradeEvent)
{
ulong itemID = tradeEvent.assetid;
if (OtherInventory != null)
{
Inventory.Item item = OtherInventory.GetItem(itemID);
Schema.Item schemaItem = CurrentSchema.GetItem(item.Defindex);
OnUserAddItem(schemaItem, item);
}
else
{
var schemaItem = GetItemFromPrivateBp(tradeEvent, itemID);
OnUserAddItem(schemaItem, null);
// todo: figure out what to send in with Inventory item.....
}
}
internal void Test_can_publish_events()
{
// Arrange
const string testAddress = "tcp://127.0.0.1:56601";
var publisher = new EventPublisher(
this.container,
new MsgPackEventSerializer(),
new BypassCompressor(),
EncryptionSettings.None(),
new Label("test-publisher"),
new Port(56601));
publisher.Start().Wait();
var subscriber = new SubscriberSocket(testAddress);
subscriber.Connect(testAddress);
subscriber.Subscribe("Event:Trade:TESTER-001");
Task.Delay(100).Wait(); // Allow socket to subscribe
var serializer = new MsgPackEventSerializer();
var order = new StubOrderBuilder().BuildMarketOrder();
var rejected = StubEventMessageProvider.OrderRejectedEvent(order);
var tradeEvent = new TradeEvent(TraderId.FromString("TESTER-001"), rejected);
// Act
publisher.Endpoint.Send(tradeEvent);
this.Output.WriteLine("Waiting for published events...");
var topic = subscriber.ReceiveFrameBytes();
var message = subscriber.ReceiveFrameBytes();
var @event = serializer.Deserialize(message);
// Assert
Assert.Equal("Event:Trade:TESTER-001", Encoding.UTF8.GetString(topic));
Assert.Equal(typeof(OrderRejected), @event.GetType());
// Tear Down
subscriber.Disconnect(testAddress);
subscriber.Dispose();
publisher.Stop().Wait();
publisher.Dispose();
}
/// <summary>
/// OnNext
/// </summary>
/// <param name="data"></param>
/// <param name="sequence"></param>
/// <param name="endOfBatch"></param>
public void OnNext(byte[] data, long sequence, bool endOfBatch)
{
object getObject = ByteArrayToObject(data);
if (getObject is Order)
{
//NOTE: Commented out due event store issues
//_eventStore.StoreEvent(getObject as Order);
// Raising Event to be handled by OrderEventListener. Moved here from ReceiveCommit.cs
OrderEvent.Raise(getObject as Order);
}
if (getObject is Trade)
{
//NOTE: Commented out due event store issues
//_eventStore.StoreEvent(getObject as Trade);
// Raising Event to be handled by TradeEventListener. Moved here from ReceiveCommit.cs
TradeEvent.Raise(getObject as Trade);
}
if (getObject is LimitOrderBook)
{
LimitOrderBook limitOrderBook = getObject as LimitOrderBook;
// Raise the event for the memory event to catch
LimitOrderBookEvent.Raise(limitOrderBook);
// Store the LimitOrderBook in the event store if no last snapshot datetime has been assigned or if the snapshot
// was taken yesterday and new day has begun
/*if ((limitOrderBook.LastSnapshotTaken == DateTime.MinValue ||
* limitOrderBook.LastSnapshotTaken.Day < DateTime.Today.Day))
* {
* _eventStore.StoreEvent(limitOrderBook);
* limitOrderBook.LastSnapshotTaken = DateTime.Now;
* }*/
}
if (getObject is Depth)
{
DepthEvent.Raise(getObject as Depth);
}
if (getObject is BBO)
{
BBOEvent.Raise(getObject as BBO);
}
}
/// <summary>
/// Gets an item from a TradeEvent, and passes it into the UserHandler's implemented OnUserAddItem([...]) routine.
/// Passes in null items if something went wrong.
/// </summary>
/// <param name="tradeEvent">TradeEvent to get item from</param>
/// <returns></returns>
private void FireOnUserAddItem(TradeEvent tradeEvent)
{
ulong itemID = tradeEvent.assetid;
Inventory.Item item;
if (OtherInventory != null)
{
item = OtherInventory.GetItem(itemID);
if (item != null)
{
Schema.Item schemaItem = CurrentSchema.GetItem(item.Defindex);
if (schemaItem == null)
{
Console.WriteLine("User added an unknown item to the trade.");
}
OnUserAddItem(schemaItem, item);
}
else
{
item = new Inventory.Item()
{
Id = itemID,
AppId = tradeEvent.appid,
ContextId = tradeEvent.contextid
};
//Console.WriteLine("User added a non TF2 item to the trade.");
OnUserAddItem(null, item);
}
}
else
{
var schemaItem = GetItemFromPrivateBp(tradeEvent, itemID);
if (schemaItem == null)
{
Console.WriteLine("User added an unknown item to the trade.");
}
OnUserAddItem(schemaItem, null);
// todo: figure out what to send in with Inventory item.....
}
}
void HandleTradeItemAdded(TradeSession trade, TradeEvent @event)
{
if (@event.item.appid != TF2App)
{
Logger.WriteLine("Ignored item: not TF2 item...");
return;
}
var asset = trade.ForeignInventory.LookupItem(@event.item);
var item = GetItemFromAsset(asset);
if (item == null)
{
Logger.WriteLine("Unknown item added: " + @event.item);
return;
}
Logger.WriteLine("Item added: " + item.ItemName);
}
/// <summary>
/// Gets an item from a TradeEvent, and passes it into the UserHandler's implemented OnUserAddItem([...]) routine.
/// Passes in null items if something went wrong.
/// </summary>
/// <param name="tradeEvent">TradeEvent to get item from</param>
/// <returns></returns>
private void FireOnUserAddItem(TradeEvent tradeEvent, SteamID botId)
{
bool isCurrency = tradeEvent.currencyid != 0;
var item = OtherInventory.GetItem(tradeEvent.appid, tradeEvent.contextid, isCurrency ? tradeEvent.currencyid : tradeEvent.assetid, isCurrency);
if (item == null)
{
if (GenericInventory.ShouldFetchInventory(tradeEvent.appid, MySteamId))
{
OtherInventory.AddForeignInventory(new SteamID(Convert.ToUInt64(tradeEvent.steamid)), botId, tradeEvent.appid, tradeEvent.contextid);
item = OtherInventory.GetItem(tradeEvent.appid, tradeEvent.contextid, isCurrency ? tradeEvent.currencyid : tradeEvent.assetid, isCurrency);
}
}
else
{
item.Amount = tradeEvent.amount;
}
OnUserAddItem(item);
}
/// <summary>
/// Gets an item from a TradeEvent, and passes it into the UserHandler's implemented OnUserRemoveItem([...]) routine.
/// Passes in null items if something went wrong.
/// </summary>
/// <param name="tradeEvent">TradeEvent to get item from</param>
/// <returns></returns>
private void FireOnUserRemoveItem(TradeEvent tradeEvent)
{
ulong itemID = (ulong)tradeEvent.assetid;
Inventory.Item item;
if (OtherInventory != null)
{
item = OtherInventory.GetItem(itemID);
if (item != null)
{
Schema.Item schemaItem = CurrentSchema.GetItem(item.Defindex);
if (schemaItem == null)
{
// TODO: Add log (counldn't find item in CurrentSchema)
}
OnUserRemoveItem(schemaItem, item);
}
else
{
// TODO: Log this (Couldn't find item in user's inventory can't find item in CurrentSchema
item = new Inventory.Item()
{
Id = itemID,
AppId = tradeEvent.appid,
ContextId = tradeEvent.contextid
};
OnUserRemoveItem(null, item);
}
}
else
{
var schemaItem = GetItemFromPrivateBp(tradeEvent, itemID);
if (schemaItem == null)
{
// TODO: Add log (counldn't find item in CurrentSchema)
}
OnUserRemoveItem(schemaItem, null);
}
}
/// <summary>
/// Checks if offer is already sold.
/// </summary>
/// <param name="tradeEvent">The trade event.</param>
private bool CheckIfOfferIsAlreadySold(TradeEvent tradeEvent)
{
var location = tradeEvent.Location.ToString();
var defaultLocation = new Location().ToString();
if (location != defaultLocation)
{
foreach (var lastOffer in this._lastOffers)
{
if (tradeEvent.ItemName == lastOffer.ItemName)
{
if (location == lastOffer.Location.ToString())
{
return(true);
}
}
}
}
return(false);
}
void ProcessCurrentTrade()
{
if (CurrentTrade == null)
{
return;
}
CurrentTrade.Update();
TradeEvent @event = null;
while (CurrentTrade.Events.TryDequeue(out @event))
{
//Logger.WriteLine("Got event: " + evt.type);
HandleTradeEvent(CurrentTrade, @event);
}
if (CurrentTrade.Status != ETradeTransactionStatus.InProgress)
{
CurrentTrade = null;
}
}
/// <summary>
/// Handles the ClipboardChanged event of the ClipboardMonitor control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="SharpClipboard.ClipboardChangedEventArgs"/> instance containing the event data.</param>
/// <exception cref="NotImplementedException"></exception>
private void ClipboardMonitor_ClipboardChanged(object sender, SharpClipboard.ClipboardChangedEventArgs e)
{
if (e.ContentType == SharpClipboard.ContentTypes.Text)
{
var currentText = e.Content as string;
if (string.IsNullOrEmpty(currentText))
{
return;
}
if (this._lastClipboardText == currentText)
{
return;
}
this._lastClipboardText = currentText;
if (TradeEvent.IsTradeMessage(currentText))
{
this.NewOffer?.Invoke(this, currentText);
}
}
}
/// <summary>
/// Lurkers the new offer.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The trade event.</param>
private async void Lurker_IncomingOffer(object sender, TradeEvent e)
{
if (this.TradeOffers.Any(o => o.Event.Equals(e)))
{
return;
}
if (this.SettingsService.AlertEnabled)
{
this.PlayAlert();
}
if (PoeApplicationContext.IsAfk)
{
await this._pushBulletService.SendTradeMessageAsync(e);
}
Execute.OnUIThread(() =>
{
this.TradeOffers.Add(new OfferViewModel(e, this._keyboardHelper, this._context, this.SettingsService, this.CheckIfOfferIsAlreadySold(e), this.DockingHelper));
});
}
/// <summary>
/// Handles the ClipboardChanged event of the ClipboardMonitor control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="SharpClipboard.ClipboardChangedEventArgs"/> instance containing the event data.</param>
/// <exception cref="NotImplementedException"></exception>
private void ClipboardMonitor_ClipboardChanged(object sender, SharpClipboard.ClipboardChangedEventArgs e)
{
if (e.ContentType == SharpClipboard.ContentTypes.Text)
{
var currentText = e.Content as string;
if (string.IsNullOrEmpty(currentText))
{
return;
}
if (this._lastClipboardText == currentText)
{
return;
}
if (Keyboard.IsKeyDown(Key.LeftShift))
{
return;
}
var isTradeMessage = false;
this._lastClipboardText = currentText;
if (TradeEvent.IsTradeMessage(currentText))
{
isTradeMessage = true;
}
else if (TradeEventHelper.IsTradeMessage(currentText))
{
isTradeMessage = true;
}
if (isTradeMessage)
{
this.NewOffer?.Invoke(this, currentText);
}
}
}
void HandleTradeTextCommand(TradeSession trade, TradeEvent @event)
{
SendChatDelegate sendDelegate = (sender, entry, text) =>
{
trade.SendChatMessage(text);
};
TradeCommand cmd;
if (!HandleCommandCommon(
@event.message, @event.sender, sendDelegate, out cmd))
{
return;
}
var messageMap = new Dictionary <TradeCommand, Action <string, TradeSession> >
{
{ TradeCommand.Help, HandleTradeHelpCommand },
{ TradeCommand.Ready, HandleTradeReadyCommand },
{ TradeCommand.Add, HandleTradeAddCommand },
{ TradeCommand.Remove, HandleTradeRemoveCommand },
{ TradeCommand.Confirm, HandleTradeConfirmCommand },
{ TradeCommand.Items, HandleTradeItemsCommand },
{ TradeCommand.Cancel, HandleTradeCancelCommand },
};
Action <string, TradeSession> func;
if (!messageMap.TryGetValue(cmd, out func))
{
Logger.WriteLine("Unhandled trade command: {0}", cmd);
return;
}
func(@event.message, trade);
}
//////////////////////////////////////////////////////////////////////////////////
//交易测试
static void TradeTest()
{
//创建 ITrade
// char* path 指 xxx.exe 同级子目录中的 xxx.dll 文件
int err = -1;
trade = ITradeApi.XFinApi_CreateTradeApi("XTA_W64/Api/CTP_v6.3.6_20160606/XFinApi.CTPTradeApi.dll", out err);
if (err > 0 || trade == null)
{
Console.WriteLine(string.Format("* Trade XFinApiCreateError={0};", StrCreateErrors[err]));
return;
}
//注册事件
tradeEvent = new TradeEvent();
trade.SetListener(tradeEvent);
//连接服务器
//Cfg.SetNonTradeTime();//非交易时段
OpenParams openParams = new OpenParams();
openParams.HostAddress = Cfg.TradeAddress;
openParams.BrokerID = Cfg.BrokerID;
openParams.UserID = Cfg.UserName;
openParams.Password = Cfg.Password;
openParams.IsUTF8 = true;
trade.Open(openParams);
/*
* //连接成功后才能执行查询、委托等操作，检测方法有两种：
* 1、ITrade.IsOpened()=true
* 2、TradeListener.OnNotify中
* (int)XFinApi.TradeApi.ActionKind.Open == notifyParams.ActionType &&
* (int)ResultKind.Success == notifyParams.ResultType
*/
while (!trade.IsOpened())
{
Thread.Sleep(1000);
}
QueryParams qryParam = new QueryParams();
qryParam.InstrumentID = Cfg.InstrumentID;
//查询委托单
Thread.Sleep(1000);//有些接口查询有间隔限制，如：CTP查询间隔为1秒
Console.WriteLine("Press any key to QueryOrder.");
Console.ReadKey();
trade.QueryOrder(qryParam);
//查询成交单
Thread.Sleep(3000);
Console.WriteLine("Press any key to QueryTradeOrder.");
Console.ReadKey();
trade.QueryTradeOrder(qryParam);
//查询合约
Thread.Sleep(3000);
Console.WriteLine("Press any key to QueryInstrument.");
Console.ReadKey();
trade.QueryInstrument(qryParam);
//查询持仓
Thread.Sleep(3000);
Console.WriteLine("Press any key to QueryPosition.");
Console.ReadKey();
trade.QueryPosition(qryParam);
//查询账户
Thread.Sleep(3000);
Console.WriteLine("Press any key to QueryAccount.");
Console.ReadKey();
trade.QueryAccount(qryParam);
//委托下单
Thread.Sleep(1000);
Console.WriteLine("Press any key to OrderAction.");
Console.ReadKey();
Order order = new Order();
order.InstrumentID = Cfg.InstrumentID;
order.Price = Cfg.SellPrice1;
order.Volume = 1;
order.Direction = DirectionKind.Buy;
order.OpenCloseType = OpenCloseKind.Open;
//下单高级选项，可选择性设置
order.ActionType = OrderActionKind.Insert; //下单
order.OrderType = OrderKind.Order; //标准单
order.PriceCond = PriceConditionKind.LimitPrice; //限价
order.VolumeCond = VolumeConditionKind.AnyVolume; //任意数量
order.TimeCond = TimeConditionKind.GFD; //当日有效
order.ContingentCond = ContingentCondKind.Immediately; //立即
order.HedgeType = HedgeKind.Speculation; //投机
order.ExecResult = ExecResultKind.NoExec; //没有执行
trade.OrderAction(order);
}
public void ChangePosition(TradeEvent trade)
{
Trades.Add(trade);
}
/// <summary>
/// Called when [file changed].
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="FileSystemEventArgs"/> instance containing the event data.</param>
private void OnFileChanged(string newline)
{
if (string.IsNullOrEmpty(newline))
{
return;
}
// TradeEvent need to be parse before whisper
var tradeEvent = TradeEvent.TryParse(newline);
if (tradeEvent != null)
{
this.NewOffer?.Invoke(this, tradeEvent);
return;
}
var whisperEvent = WhisperEvent.TryParse(newline);
if (whisperEvent != null)
{
this.Whispered?.Invoke(this, whisperEvent);
return;
}
var locationEvent = LocationChangedEvent.TryParse(newline);
if (locationEvent != null)
{
this.LocationChanged?.Invoke(this, locationEvent);
return;
}
var tradeAcceptedEvent = TradeAcceptedEvent.TryParse(newline);
if (tradeAcceptedEvent != null)
{
this.TradeAccepted?.Invoke(this, tradeAcceptedEvent);
return;
}
var monsterEvent = MonstersRemainEvent.TryParse(newline);
if (monsterEvent != null)
{
this.RemainingMonsters?.Invoke(this, monsterEvent);
return;
}
var playerJoinEvent = PlayerJoinedEvent.TryParse(newline);
if (playerJoinEvent != null)
{
this.PlayerJoined?.Invoke(this, playerJoinEvent);
return;
}
var playerLeftEvent = PlayerLeftEvent.TryParse(newline);
if (playerLeftEvent != null)
{
this.PlayerLeft?.Invoke(this, playerLeftEvent);
return;
}
Logger.Trace($"Not parsed: {newline}");
}
protected override void AddTrade(TradeEvent tradeEvent)
{
Ticks.Add(tradeEvent.Tick);
}
//////////////////////////////////////////////////////////////////////////////////
//交易测试
static void TradeTest()
{
//创建 ITrade
// char* path 指 xxx.exe 同级子目录中的 xxx.dll 文件
int err = -1;
trade = ITradeApi.XFinApi_CreateTradeApi("XTA_W32/Api/XTP_v1.1.18.13_20180516/XFinApi.XTPTradeApi.dll", out err);
if (err > 0 || trade == null)
{
Console.WriteLine(string.Format("* Trade XFinApiCreateError={0};", StrCreateErrors[err]));
return;
}
//注册事件
tradeEvent = new TradeEvent();
trade.SetListener(tradeEvent);
//连接服务器
OpenParams openParams = new OpenParams();
openParams.HostAddress = Cfg.TradeAddress;
openParams.UserID = Cfg.UserName;
openParams.Password = Cfg.Password;
openParams.Configs.Add("AuthCode", Cfg.AuthCode);
openParams.Configs.Add("ClientID", Cfg.ClientID);//可选
openParams.IsUTF8 = true;
trade.Open(openParams);
/*
* //连接成功后才能执行查询、委托等操作，检测方法有两种：
* 1、ITrade.IsOpened()=true
* 2、TradeListener.OnNotify中
* (int)XFinApi.TradeApi.ActionKind.Open == notifyParams.ActionType &&
* (int)ResultKind.Success == notifyParams.ResultType
*/
while (!trade.IsOpened())
{
Thread.Sleep(1000);
}
QueryParams qryParam = new QueryParams();
//查询委托单
Thread.Sleep(1000);//有些接口查询有间隔限制，如：CTP查询间隔为1秒
Console.WriteLine("Press any key to QueryOrder.");
Console.ReadKey();
trade.QueryOrder(qryParam);
//查询成交单
Thread.Sleep(3000);
Console.WriteLine("Press any key to QueryTradeOrder.");
Console.ReadKey();
trade.QueryTradeOrder(qryParam);
//查询合约
Thread.Sleep(3000);
Console.WriteLine("Press any key to QueryInstrument.");
Console.ReadKey();
trade.QueryInstrument(qryParam);
//查询持仓
Thread.Sleep(3000);
Console.WriteLine("Press any key to QueryPosition.");
Console.ReadKey();
trade.QueryPosition(qryParam);
//查询账户
Thread.Sleep(3000);
Console.WriteLine("Press any key to QueryAccount.");
Console.ReadKey();
trade.QueryAccount(qryParam);
//委托下单
Thread.Sleep(1000);
Console.WriteLine("Press any key to OrderAction.");
Console.ReadKey();
Order order = new Order();
order.ExchangeID = Cfg.MarketID;
order.InstrumentID = Cfg.InstrumentID;
order.Price = Cfg.SellPrice1;
order.Volume = 100;
order.Direction = DirectionKind.Buy;
//下单高级选项，可选择性设置
order.ActionType = OrderActionKind.Insert; //下单
order.OrderType = OrderKind.Order; //标准单
order.PriceCond = PriceConditionKind.LimitPrice; //限价
trade.OrderAction(order);
}
void HandleTradeConfirmed(TradeSession trade, TradeEvent @event)
{
Logger.WriteLine("Trade confirmed.");
trade.Confirm();
}
/// <summary>
/// Initializes a new instance of the <see cref="PositionViewModel"/> class.
/// </summary>
/// <param name="tradeEvent">The trade event.</param>
public PositionViewModel(TradeEvent tradeEvent)
{
this._tradeEvent = tradeEvent;
}
/// <summary>
/// Initializes a new instance of the <see cref="TradeValueViewModel" /> class.
/// </summary>
/// <param name="tradeEvent">The trade event.</param>
/// <param name="settingsService">The settings service.</param>
public TradeValueViewModel(TradeEvent tradeEvent, SettingsService settingsService)
{
this._tradeEvent = tradeEvent;
this._settingsService = settingsService;
}
public PositionViewModel(TradeEvent tradeEvent)
{
this._tradeEvent = tradeEvent;
this._ItemClass = ItemClassParser.Parse(tradeEvent.ItemName);
}
private async Task <string> WriteOHLC(TradeEvent ev, DateTimeOffset?timestamp)
{
try
{
string tokenSymbol;
decimal tokenAmount, ethAmount, price = 0;
TokenModel token;
if (ev.TokenGet == NullAddress)
{
token = await _context.Token.FirstOrDefaultAsync(x => x.Token == ev.TokenGive);
tokenSymbol = token.Symbol;
var d = await _cache.GetOrCreateAsync(ev.TokenGive, entry =>
{
entry.SlidingExpiration = TimeSpan.FromSeconds(5);
var tokenContract = new StandardTokenService(_nethereumClient, ev.TokenGive);
var decimals = tokenContract.DecimalsQueryAsync(new DecimalsFunction()).Result;
return(Task.FromResult((decimal)Math.Pow(10, decimals)));
});
tokenAmount = (decimal)BigInteger.DivRem(ev.AmountGive, new BigInteger(d), out var remainder);
if (remainder > 0)
{
tokenAmount += (decimal)remainder / d;
}
ethAmount = UnitConversion.Convert.FromWei(ev.AmountGet, UnitConversion.EthUnit.Ether);
if (tokenAmount > 0)
{
price = ethAmount / tokenAmount;
}
}
else
{
token = await _context.Token.FirstOrDefaultAsync(x => x.Token == ev.TokenGet);
tokenSymbol = token.Symbol;
var d = await _cache.GetOrCreateAsync(ev.TokenGet, entry =>
{
entry.SlidingExpiration = TimeSpan.FromSeconds(5);
var tokenContract = new StandardTokenService(_nethereumClient, ev.TokenGive);
var decimals = tokenContract.DecimalsQueryAsync(new DecimalsFunction()).Result;
return(Task.FromResult((decimal)Math.Pow(10, decimals)));
});
tokenAmount = (decimal)BigInteger.DivRem(ev.AmountGet, new BigInteger(d), out var remainder);
if (remainder > 0)
{
tokenAmount += (decimal)remainder / d;
}
ethAmount = UnitConversion.Convert.FromWei(ev.AmountGive, UnitConversion.EthUnit.Ether);
if (tokenAmount > 0)
{
price = ethAmount / tokenAmount;
}
}
_ohclService.WriteOHLC(price, tokenAmount, token.Symbol, timestamp.Value.UtcDateTime);
return(tokenSymbol);
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
private void WsClient_OnTrade(TradeEvent tradeEvent)
{
Console.WriteLine(tradeEvent);
//here you can make your trade decision
}
private void processMessage(byte[] receivedData)
{
// parsing response
using (MemoryStream responseStream = new MemoryStream(receivedData))
{
protobuf.ws.WsResponse response = ProtoBuf.Serializer.Deserialize <protobuf.ws.WsResponse>(responseStream);
if (response.Meta.ResponseType == protobuf.ws.WsResponseMetaData.WsResponseMsgType.TickerChannelSubscribed)
{
using (MemoryStream messageStream = new MemoryStream(response.Msg))
{
protobuf.ws.TickerChannelSubscribedResponse message = ProtoBuf.Serializer.Deserialize <protobuf.ws.TickerChannelSubscribedResponse>(messageStream);
string channelId = "Ticker_" + message.CurrencyPair;
WsClient_OnSubscribe(channelId);
message.Datas.ForEach(delegate(protobuf.ws.TickerEvent evt) {
TickerEvent preparedEvent = prepareTickerEvent(evt);
preparedEvent.ChannelId = channelId;
WsClient_OnTicker(preparedEvent);
});
}
}
else if (response.Meta.ResponseType == protobuf.ws.WsResponseMetaData.WsResponseMsgType.TickerNotify)
{
using (MemoryStream messageStream = new MemoryStream(response.Msg))
{
protobuf.ws.TickerNotification message = ProtoBuf.Serializer.Deserialize <protobuf.ws.TickerNotification>(messageStream);
string channelId = "Ticker_" + message.CurrencyPair;
message.Datas.ForEach(delegate(protobuf.ws.TickerEvent evt) {
TickerEvent preparedEvent = prepareTickerEvent(evt);
preparedEvent.ChannelId = channelId;
WsClient_OnTicker(preparedEvent);
});
}
}
if (response.Meta.ResponseType == protobuf.ws.WsResponseMetaData.WsResponseMsgType.TradeChannelSubscribed)
{
using (MemoryStream messageStream = new MemoryStream(response.Msg))
{
protobuf.ws.TradeChannelSubscribedResponse message = ProtoBuf.Serializer.Deserialize <protobuf.ws.TradeChannelSubscribedResponse>(messageStream);
string channelId = "Trade_" + message.CurrencyPair;
WsClient_OnSubscribe(channelId);
message.Datas.ForEach(delegate(protobuf.ws.TradeEvent evt) {
TradeEvent preparedEvent = prepareTradeEvent(evt);
preparedEvent.ChannelId = channelId;
WsClient_OnTrade(preparedEvent);
});
}
}
else if (response.Meta.ResponseType == protobuf.ws.WsResponseMetaData.WsResponseMsgType.TradeNotify)
{
using (MemoryStream messageStream = new MemoryStream(response.Msg))
{
protobuf.ws.TradeNotification message = ProtoBuf.Serializer.Deserialize <protobuf.ws.TradeNotification>(messageStream);
string channelId = "Trade_" + message.CurrencyPair;
message.Datas.ForEach(delegate(protobuf.ws.TradeEvent evt) {
TradeEvent preparedEvent = prepareTradeEvent(evt);
preparedEvent.ChannelId = channelId;
WsClient_OnTrade(preparedEvent);
});
}
}
else if (response.Meta.ResponseType == protobuf.ws.WsResponseMetaData.WsResponseMsgType.Error)
{
using (MemoryStream messageStream = new MemoryStream(response.Msg))
{
protobuf.ws.ErrorResponse message = ProtoBuf.Serializer.Deserialize <protobuf.ws.ErrorResponse>(messageStream);
WsClient_OnError(response.Meta.Token, message.Code, message.Message);
}
}
else if (response.Meta.ResponseType == protobuf.ws.WsResponseMetaData.WsResponseMsgType.ChannelUnsubscribed)
{
using (MemoryStream messageStream = new MemoryStream(response.Msg)) {
protobuf.ws.ChannelUnsubscribedResponse message = ProtoBuf.Serializer.Deserialize <protobuf.ws.ChannelUnsubscribedResponse>(messageStream);
if (message.Type == protobuf.ws.UnsubscribeRequest.ChannelType.Ticker)
{
WsClient_OnUnsubscribe("Ticker_" + message.CurrencyPair);
}
else if (message.Type == protobuf.ws.UnsubscribeRequest.ChannelType.Trade)
{
WsClient_OnUnsubscribe("Trade_" + message.CurrencyPair);
}
}
}
else if (response.Meta.ResponseType == protobuf.ws.WsResponseMetaData.WsResponseMsgType.LoginResponse)
{
WsClient_OnLogin();
}
// here you can make your trade decision
}
}
private void HandleTradeItem(object sender, MessageData item)
{
var data = JsonSerializer.Deserialize <Trade>(item.Data);
TradeEvent?.Invoke(sender, data);
}
/// <summary>
/// Initializes a new instance of the <see cref="TradeValueViewModel"/> class.
/// </summary>
/// <param name="tradeEvent">The trade event.</param>
public TradeValueViewModel(TradeEvent tradeEvent)
{
this._tradeEvent = tradeEvent;
}
/// <summary>
/// Called when [file changed].
/// </summary>
/// <param name="newline">The newline.</param>
private void OnFileChanged(string newline)
{
if (string.IsNullOrEmpty(newline))
{
return;
}
try
{
// TradeEvent need to be parse before whisper
var tradeEvent = TradeEvent.TryParse(newline);
if (tradeEvent != null)
{
this.HandleLeague(tradeEvent);
this.IncomingOffer?.Invoke(this, tradeEvent);
return;
}
var outgoingTradeEvent = OutgoingTradeEvent.TryParse(newline);
if (outgoingTradeEvent != null)
{
this.HandleLeague(outgoingTradeEvent);
this.OutgoingOffer?.Invoke(this, outgoingTradeEvent);
return;
}
var levelUpEvent = PlayerLevelUpEvent.TryParse(newline);
if (levelUpEvent != null)
{
this.PlayerLevelUp?.Invoke(this, levelUpEvent);
return;
}
var whisperEvent = WhisperEvent.TryParse(newline);
if (whisperEvent != null)
{
this.Whispered?.Invoke(this, whisperEvent);
return;
}
var locationEvent = LocationChangedEvent.TryParse(newline);
if (locationEvent != null)
{
Models.PoeApplicationContext.Location = locationEvent.Location;
this.LocationChanged?.Invoke(this, locationEvent);
return;
}
var afkEvent = AfkEvent.TryParse(newline);
if (afkEvent != null)
{
if (Models.PoeApplicationContext.IsAfk != afkEvent.AfkEnable)
{
Models.PoeApplicationContext.IsAfk = afkEvent.AfkEnable;
}
this.AfkChanged?.Invoke(this, afkEvent);
return;
}
var tradeAcceptedEvent = TradeAcceptedEvent.TryParse(newline);
if (tradeAcceptedEvent != null)
{
this.TradeAccepted?.Invoke(this, tradeAcceptedEvent);
return;
}
var monsterEvent = MonstersRemainEvent.TryParse(newline);
if (monsterEvent != null)
{
this.RemainingMonsters?.Invoke(this, monsterEvent);
return;
}
var playerJoinEvent = PlayerJoinedEvent.TryParse(newline);
if (playerJoinEvent != null)
{
this.PlayerJoined?.Invoke(this, playerJoinEvent);
return;
}
var playerLeftEvent = PlayerLeftEvent.TryParse(newline);
if (playerLeftEvent != null)
{
this.PlayerLeft?.Invoke(this, playerLeftEvent);
return;
}
Logger.Trace($"Not parsed: {newline}");
}
catch (Exception ex)
{
var lineError = $"Line in error: {newline}";
var exception = new Exception(lineError, ex);
Logger.Error(exception, exception.Message);
#if !DEBUG
SentrySdk.AddBreadcrumb(message: lineError, level: BreadcrumbLevel.Error);
SentrySdk.CaptureException(ex);
#endif
}
}
/// <summary>
/// This updates the trade. This is called at an interval of a
/// default of 800ms, not including the execution time of the
/// method itself.
/// </summary>
/// <returns><c>true</c> if the other trade partner performed an action; otherwise <c>false</c>.</returns>
public bool Poll()
{
bool otherDidSomething = false;
if (!TradeStarted)
{
tradeStarted = true;
// since there is no feedback to let us know that the trade
// is fully initialized we assume that it is when we start polling.
if (OnAfterInit != null)
{
OnAfterInit();
}
}
TradeStatus status = session.GetStatus();
if (status == null)
{
throw new TradeException("The web command to get the trade status failed.");
}
switch (status.trade_status)
{
// Nothing happened. i.e. trade hasn't closed yet.
case 0:
break;
// Successful trade
case 1:
HasTradeCompletedOk = true;
return(otherDidSomething);
// All other known values (3, 4) correspond to trades closing.
default:
if (OnError != null)
{
OnError("Trade was closed by other user. Trade status: " + status.trade_status);
}
OtherUserCancelled = true;
return(otherDidSomething);
}
if (status.newversion)
{
// handle item adding and removing
session.Version = status.version;
TradeEvent trdEvent = status.GetLastEvent();
TradeEventType actionType = (TradeEventType)trdEvent.action;
HandleTradeVersionChange(status);
return(true);
}
else if (status.version > session.Version)
{
// oh crap! we missed a version update abort so we don't get
// scammed. if we could get what steam thinks what's in the
// trade then this wouldn't be an issue. but we can only get
// that when we see newversion == true
throw new TradeException("The trade version does not match. Aborting.");
}
var events = status.GetAllEvents();
foreach (var tradeEvent in events)
{
if (eventList.Contains(tradeEvent))
{
continue;
}
//add event to processed list, as we are taking care of this event now
eventList.Add(tradeEvent);
bool isBot = tradeEvent.steamid == MySteamId.ConvertToUInt64().ToString();
// dont process if this is something the bot did
if (isBot)
{
continue;
}
otherDidSomething = true;
/* Trade Action ID's
* 0 = Add item (itemid = "assetid")
* 1 = remove item (itemid = "assetid")
* 2 = Toggle ready
* 3 = Toggle not ready
* 4 = ?
* 5 = ? - maybe some sort of cancel
* 6 = ?
* 7 = Chat (message = "text") */
switch ((TradeEventType)tradeEvent.action)
{
case TradeEventType.ItemAdded:
FireOnUserAddItem(tradeEvent);
break;
case TradeEventType.ItemRemoved:
FireOnUserRemoveItem(tradeEvent);
break;
case TradeEventType.UserSetReady:
otherIsReady = true;
OnUserSetReady(true);
break;
case TradeEventType.UserSetUnReady:
otherIsReady = false;
OnUserSetReady(false);
break;
case TradeEventType.UserAccept:
OnUserAccept();
break;
case TradeEventType.UserChat:
OnMessage(tradeEvent.text);
break;
default:
// Todo: add an OnWarning or similar event
if (OnError != null)
{
OnError("Unknown Event ID: " + tradeEvent.action);
}
break;
}
}
// Update Local Variables
if (status.them != null)
{
otherIsReady = status.them.ready == 1;
meIsReady = status.me.ready == 1;
}
if (status.logpos != 0)
{
session.LogPos = status.logpos;
}
return(otherDidSomething);
}
