internal static void Handle(JToken token, SubscribedResponse subscription,
Subject<LiquidationFeedStatus> subject)
{
var data = token[1];
if (data.Type != JTokenType.Array)
{
// probably heartbeat, ignore
return;
}
// TODO: check if liquidation updates are always arrays
if (data.First.Type == JTokenType.Array)
{
// initial snapshot
var liquidations = data.ToObject<LiquidationFeedStatus[]>();
foreach (var liquidation in liquidations)
{
liquidation.ChanId = subscription.ChanId;
subject.OnNext(liquidation);
}
return;
}
var derivativePairStatus = data.ToObject<LiquidationFeedStatus>();
derivativePairStatus.ChanId = subscription.ChanId;
subject.OnNext(derivativePairStatus);
}
internal static void Handle(JToken token, SubscribedResponse subscription, ConfigurationState config,
Subject <Book> subject, Subject <Book[]> subjectSnapshot, Subject <ChecksumResponse> subjectChecksum)
{
var data = token[1];
if (config.IsChecksumEnabled)
{
if (data?.Type == JTokenType.String && data.Value <string>() == "cs")
{
ChecksumResponse.Handle(token, subscription, config, subjectChecksum);
return;
}
}
if (data?.Type != JTokenType.Array)
{
return; // heartbeat, ignore
}
if (data.First?.Type == JTokenType.Array)
{
// initial snapshot
Handle(token, data.ToObject <Book[]>(), subscription, config, subject, subjectSnapshot);
return;
}
var book = data.ToObject <Book>();
book.Pair = subscription.Pair;
book.Symbol = subscription.Symbol;
book.ChanId = subscription.ChanId;
SetGlobalData(book, config, token);
subject.OnNext(book);
}
private void OnSubscription(SubscribedResponse response)
{
var channelId = response.ChanId;
switch (response.Channel)
{
case "ticker":
_channelIdToHandler[channelId] = data => OnTicker(data, response);
break;
case "trades":
//if pair is null means that is funding
if (response.Pair == null)
{
_channelIdToHandler[channelId] = data => OnFundings(data, response);
}
else
{
_channelIdToHandler[channelId] = data => OnTrades(data, response);
}
break;
case "candles":
_channelIdToHandler[channelId] = data => OnCandles(data, response);
break;
case "book":
_channelIdToHandler[channelId] = data => OnBook(data, response);
break;
}
}
private void OnSubscription(SubscribedResponse response)
{
_streams.SubscriptionSubject.OnNext(response);
var channelId = response.ChanId;
// ********************
// ADD HANDLERS BELOW
// ********************
switch (response.Channel)
{
case "ticker":
_channelIdToHandler[channelId] = (data, config) =>
Ticker.Handle(data, response, config, _streams.TickerSubject);
break;
case "trades":
//if pair is null means that is funding
if (response.Pair == null)
{
_channelIdToHandler[channelId] = (data, config) =>
Funding.Handle(data, response, config, _streams.FundingsSubject);
}
else
{
_channelIdToHandler[channelId] = (data, config) =>
Trade.Handle(data, response, config, _streams.TradesSubject, _streams.TradesSnapshotSubject);
}
break;
case "candles":
_channelIdToHandler[channelId] = (data, config) =>
Candles.Handle(data, response, _streams.CandlesSubject);
break;
case "book":
_channelIdToHandler[channelId] = (data, config) =>
Book.Handle(data, response, config, _streams.BookSubject, _streams.BookSnapshotSubject, _streams.BookChecksumSubject);
break;
case "status":
if (response.Key.StartsWith("deriv"))
{
_channelIdToHandler[channelId] = (data, config) =>
DerivativePairStatus.Handle(data, response, _streams.DerivativePairSubject);
}
if (response.Key.StartsWith("liq"))
{
_channelIdToHandler[channelId] = (data, config) =>
LiquidationFeedStatus.Handle(data, response, _streams.LiquidationFeedSubject);
}
break;
//default:
// Log.Warning($"Missing subscription handler '{response.Channel}'");
// break;
}
}
public static bool Equals(ArticleInfoResponse?left, ArticleInfoResponse?right)
{
bool result = SubscribedResponse.Equals(left, right);
result &= (result ? (left?.Articles.SequenceEqual(right?.Articles)).GetValueOrDefault() : false);
return(result);
}
public static bool Equals(ShoppingCartResponse?left, ShoppingCartResponse?right)
{
bool result = SubscribedResponse.Equals(left, right);
result &= (result ? ShoppingCartContent.Equals(left?.ShoppingCart, right?.ShoppingCart) : false);
return(result);
}
public static bool Equals(ArticleMasterSetResponse?left, ArticleMasterSetResponse?right)
{
bool result = SubscribedResponse.Equals(left, right);
result &= (result ? ArticleMasterSetResult.Equals(left?.Result, right?.Result) : false);
return(result);
}
public static bool Equals(StockDeliverySetResponse?left, StockDeliverySetResponse?right)
{
bool result = SubscribedResponse.Equals(left, right);
result &= (result ? StockDeliverySetResult.Equals(left?.Result, right?.Result) : false);
return(result);
}
public static bool Equals(TaskCancelOutputResponse?left, TaskCancelOutputResponse?right)
{
bool result = SubscribedResponse.Equals(left, right);
result &= (result ? (left?.Tasks.SequenceEqual(right?.Tasks)).GetValueOrDefault() : false);
return(result);
}
public static bool Equals(OutputInfoResponse?left, OutputInfoResponse?right)
{
bool result = SubscribedResponse.Equals(left, right);
result &= (result ? OutputInfoResponseTask.Equals(left?.Task, right?.Task) : false);
return(result);
}
public static bool Equals(StatusResponse?left, StatusResponse?right)
{
bool result = SubscribedResponse.Equals(left, right);
result &= (result ? (left?.Components.SequenceEqual(right?.Components)).GetValueOrDefault() : false);
return(result);
}
public static bool Equals(StockDeliveryInfoResponse?left, StockDeliveryInfoResponse?right)
{
bool result = SubscribedResponse.Equals(left, right);
result &= (result ? StockDeliveryInfoResponseTask.Equals(left?.Task, right?.Task) : false);
return(result);
}
public static bool Equals(StockLocationInfoResponse?left, StockLocationInfoResponse?right)
{
bool result = SubscribedResponse.Equals(left, right);
result &= (result ? (left?.StockLocations.SequenceEqual(right?.StockLocations)).GetValueOrDefault() : false);
return(result);
}
public static bool Equals(ConfigurationGetResponse?left, ConfigurationGetResponse?right)
{
bool result = SubscribedResponse.Equals(left, right);
result &= (result ? Configuration.Equals(left?.Configuration, right?.Configuration) : false);
return(result);
}
public static bool Equals(ArticlePriceResponse?left, ArticlePriceResponse?right)
{
bool result = SubscribedResponse.Equals(left, right);
result &= (result ? (left?.Articles.SequenceEqual(right?.Articles)).GetValueOrDefault() : false);
result &= (result ? Iso4217Code.Equals(left?.Currency, right?.Currency) : false);
return(result);
}
public void OnChannelCreated(SubscribedResponse subscribedResponse)
{
if (subscribedResponse.Event == "subscribed")
{
var aggregatorType = (subscribedResponse.Precision == "R0") ? AggregatorType.RawBooks : AggregatorType.Books;
var channeldId = subscribedResponse.ChannelId;
_aggregators.Add(channeldId, CreateAggregator(aggregatorType, channeldId, subscribedResponse.Pair));
}
}
public static bool Equals(InputResponse?left, InputResponse?right)
{
bool result = SubscribedResponse.Equals(left, right);
result &= (result ? EqualityComparer <bool?> .Default.Equals(left?.IsNewDelivery, right?.IsNewDelivery) : false);
result &= (result ? (left?.Articles.SequenceEqual(right?.Articles)).GetValueOrDefault() : false);
return(result);
}
private void OnBooks(Book[] books, SubscribedResponse subscription)
{
//var reversed = books.Reverse().ToArray(); // newest last
foreach (var book in books)
{
book.Pair = subscription.Pair;
book.ChanId = subscription.ChanId;
Streams.Raise(book);
}
}
public static bool Equals(OutputResponse?left, OutputResponse?right)
{
bool result = SubscribedResponse.Equals(left, right);
result &= (result ? OutputRequestDetails.Equals(left?.Details, right?.Details) : false);
result &= (result ? String.Equals(left?.BoxNumber, right?.BoxNumber, StringComparison.OrdinalIgnoreCase) : false);
result &= (result ? (left?.Criterias.SequenceEqual(right?.Criterias)).GetValueOrDefault() : false);
return(result);
}
private async Task HandleResponse(SubscribedResponse response)
{
await Log.WriteInfoAsync(nameof(HandleResponse), "Subscribing on the order book", $"Event: {response.Event} Channel: {response.Channel} Pair: {response.Pair}");
if (!_channels.TryGetValue(response.ChanId, out var channel))
{
channel = new Channel(response.ChanId, response.Pair);
_channels[channel.Id] = channel;
}
}
private void OnSubscription(SubscribedResponse response)
{
var channelId = response.ChanId;
switch (response.Channel)
{
case "ticker":
_channelIdToHandler[channelId] = data => OnTicker(data, response);
break;
}
}
private void OnTrades(Trade[] trades, SubscribedResponse subscription)
{
var reversed = trades.Reverse().ToArray(); // newest last
foreach (var trade in reversed)
{
trade.Type = TradeType.Executed;
trade.Pair = subscription.Pair;
trade.ChanId = subscription.ChanId;
Streams.Raise(trade);
}
}
private void OnFundings(Funding[] fundings, SubscribedResponse subscription)
{
var reversed = fundings.Reverse().ToArray(); // newest last
foreach (var funding in reversed)
{
funding.Type = FundingType.Executed;
funding.Symbol = subscription.Symbol;
funding.ChanId = subscription.ChanId;
Streams.Raise(funding);
}
}
internal static void Handle(JToken token, Trade[] trades, SubscribedResponse subscription, ConfigurationState config, Subject <Trade[]> subject)
{
var reversed = trades.Reverse().ToArray(); // newest last
foreach (var trade in reversed)
{
trade.Type = TradeType.Executed;
trade.Pair = subscription.Pair;
trade.ChanId = subscription.ChanId;
SetGlobalData(trade, config, token);
}
subject.OnNext(reversed);
}
internal static void Handle(JToken token, Funding[] fundings, SubscribedResponse subscription,
ConfigurationState config, Subject <Funding> subject)
{
var reversed = fundings.Reverse().ToArray(); // newest last
foreach (var funding in reversed)
{
funding.Type = FundingType.Executed;
funding.Symbol = subscription.Symbol;
funding.ChanId = subscription.ChanId;
SetGlobalData(funding, config, token);
subject.OnNext(funding);
}
}
private void OnBooks(Book[] books, SubscribedResponse subscription)
{
foreach (var book in books)
{
book.Pair = subscription.Pair;
book.ChanId = subscription.ChanId;
// raise as normal book stream
Streams.Raise(book);
}
// raise as snapshot book stream
Streams.Raise(books);
}
private void OnTicker(JToken token, SubscribedResponse subscription)
{
var data = token[1];
if (data.Type != JTokenType.Array)
{
// probably heartbeat, ignore
return;
}
var ticker = data.ToObject <Ticker>();
ticker.Pair = subscription.Pair;
Streams.Raise(ticker);
}
internal static void Handle(JToken token, Book[] books, SubscribedResponse subscription, ConfigurationState config,
Subject <Book> subject, Subject <Book[]> subjectSnapshot)
{
foreach (var book in books)
{
book.Pair = subscription.Pair;
book.ChanId = subscription.ChanId;
SetGlobalData(book, config, token);
// raise as normal book stream
subject.OnNext(book);
}
// raise as snapshot book stream
subjectSnapshot.OnNext(books);
}
internal static void Handle(JToken token, SubscribedResponse subscription, Subject <Candles> subject)
{
var data = token[1];
if (data.Type != JTokenType.Array)
{
// probably heartbeat, ignore
return;
}
var candles = data.ToObject <Candles>();
candles.TimeFrame = new BitfinexTimeFrame().GetFieldByStringValue(subscription.Key.Split(':')[1]);
candles.Pair = subscription.Key.Split(':')[2].Remove(0, 1);
candles.ChanId = subscription.ChanId;
subject.OnNext(candles);
}
private void OnCandles(JToken token, SubscribedResponse subscription)
{
var data = token[1];
if (data.Type != JTokenType.Array)
{
// probably heartbeat, ignore
return;
}
var candles = data.ToObject <Candles>();
candles.TimeFrame = new BitfinexTimeFrame().GetFieldByStringValue(subscription.Key.Split(':')[1]);
candles.Pair = subscription.Key.Split(':')[2].Remove(0, 1);
candles.ChanId = subscription.ChanId;
Streams.Raise(candles);
}
private void HandlePresenceRequest(Packet packet)
{
PresencePacket IncomingPresencePacket = packet as PresencePacket;
if (IncomingPresencePacket is ProbeRequest)
{
//A Probe means we should send our presence to the probing entity
//Maybe we should get some user input here. Not really sure if theyd want to know, though.
SendCurrentPresence(IncomingPresencePacket.From);
}
else if (IncomingPresencePacket is SubscribeRequest)
{
string displayString =
String.Format("Allow User '{0}; to subscribe to your presence?",
IncomingPresencePacket.From.JabberIDNoResource);
if (
MessageBox.Show(displayString, "Subscription Request", MessageBoxButtons.YesNo,
MessageBoxIcon.Question) == DialogResult.Yes)
{
SubscribedResponse resp = new SubscribedResponse(IncomingPresencePacket.From);
SessionManager.Send(resp);
SubscribeRequest subscribe =
new SubscribeRequest(new JabberID(IncomingPresencePacket.From.JabberIDNoResource));
SessionManager.Send(subscribe);
}
else
{
UnsubscribedResponse resp = new UnsubscribedResponse();
resp.To = IncomingPresencePacket.From;
SessionManager.Send(resp);
}
}
else if (IncomingPresencePacket is SubscribedResponse)
{
//Let the user know when someone accepts our subscription request
string displayString =
String.Format("User '{0}' has accepted your presence subscription request.",
IncomingPresencePacket.From.JabberIDNoResource);
MessageBox.Show(displayString, "Subscription Accept", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
else if (IncomingPresencePacket is UnsubscribedResponse)
{
//Let the user know when someone revoked our presence subscription
string displayString =
String.Format("User '{0}' rejected your reqeust.", IncomingPresencePacket.From.JabberIDNoResource);
MessageBox.Show(displayString, "Subscription Denied", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
else if (IncomingPresencePacket is AvailableRequest)
{
AvailableRequest availableReq = WConvert.ToAvailableRequest(IncomingPresencePacket);
LoginState state = LoginState.Offline;
if (availableReq.From.Server.Contains(".com"))
{
state = (LoginState) availableReq.Show;
}
else
{
state = (LoginState) Enum.Parse(typeof (LoginState), availableReq.Status);
}
string userName = availableReq.From.UserName;
Contact contact = Instance.Contacts[userName];
if (contact != null)
{
contact.UserStatus = state;
if (availableReq.HasVCardAvatarUpdateHash)
{
if (availableReq.HasJabberXAvatarHash)
{
contact.AvatatType = Contact.AvatarType.JabberXAvatar;
}
/*else - we prefere VCardAvatar*/
if (availableReq.HasVCardAvatarUpdateHash)
{
contact.AvatatType = Contact.AvatarType.VCardAvatar;
}
contact.AvatarHash = availableReq.VCardAvatarUpdateHash;
}
}
}
else if (IncomingPresencePacket is UnavailableRequest)
{
UnavailableRequest avail = WConvert.ToUnavailableRequest(IncomingPresencePacket);
string userName = avail.From.UserName;
Contact contact = Instance.Contacts[userName];
contact.UserStatus = LoginState.Offline;
}
}
private void IncomingAsycPresenceThreadSafe(Packet p)
{
PresencePacket IncomingPresencePacket = p as PresencePacket;
if (IncomingPresencePacket is Coversant.SoapBox.Core.Presence.ProbeRequest)
{
//A Probe means we should send ouur presence to the probing entity
//Maybe we should get some user input here. Not really sure if theyd want to know, though.
_SessionManager.SendCurrentPresence(IncomingPresencePacket.From);
}
else if (IncomingPresencePacket is Coversant.SoapBox.Core.Presence.SubscribeRequest)
{
string displayString = String.Format("Allow User '{0}; to subscribe to your presence?", IncomingPresencePacket.From.JabberIDNoResource);
if (MessageBox.Show(displayString, "Subscription Request", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
{
SubscribedResponse resp = new SubscribedResponse(IncomingPresencePacket.From);
_SessionManager.Send(resp);
SubscribeRequest subscribe = new SubscribeRequest(new JabberID(IncomingPresencePacket.From.JabberIDNoResource));
_SessionManager.Send(subscribe);
}
else
{
UnsubscribedResponse resp = new UnsubscribedResponse();
resp.To = IncomingPresencePacket.From;
_SessionManager.Send(resp);
}
}
else if (IncomingPresencePacket is Coversant.SoapBox.Core.Presence.SubscribedResponse)
{
//Let the user know when someone accepts our subscription request
string displayString = String.Format("User '{0}' has accepted your presence subscription request.", IncomingPresencePacket.From.JabberIDNoResource);
MessageBox.Show(displayString, "Subscription Accept", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
else if (IncomingPresencePacket is Coversant.SoapBox.Core.Presence.UnsubscribedResponse)
{
//Let the user know when someone revoked our presence subscription
string displayString = String.Format("User '{0}' rejected your reqeust.", IncomingPresencePacket.From.JabberIDNoResource);
MessageBox.Show(displayString, "Subscription Denied", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
else if (IncomingPresencePacket is Coversant.SoapBox.Core.Presence.ErrorResponse)
{
//Let the user know of any presence errors that are received
//Dim PresenceError As SoapBox.Core.Presence.ErrorResponse = CType(IncomingPresencePacket, SoapBox.Core.Presence.ErrorResponse)
//MsgBox("The following presence error was received:" & vbCrLf & vbCrLf & "Code: " & PresenceError.ErrorCode & vbCrLf & "Text: " & PresenceError.ErrorText, MsgBoxStyle.Exclamation, "Presence Error")
}
else if (IncomingPresencePacket is Coversant.SoapBox.Core.Presence.AvailableRequest)
{
AvailableRequest avail = WConvert.ToAvailableRequest(IncomingPresencePacket);
ListViewRosterItem lvri = this.GetListViewRosterItem(avail.From);
if (lvri != null)
lvri.Presence = avail;
}
else if (IncomingPresencePacket is Coversant.SoapBox.Core.Presence.UnavailableRequest)
{
UnavailableRequest avail = WConvert.ToUnavailableRequest(IncomingPresencePacket);
ListViewRosterItem lvri = this.GetListViewRosterItem(avail.From);
if (lvri != null)
lvri.Presence = avail;
}
}
