Files
spark/src/client/spark/Predicates/Data/OrderRecordTuplePredicate.cs
T

381 lines
23 KiB
C#

using bts.api;
using bts.api.orderman;
using bts.shell;
using bts.utils;
using mbts.spark;
using mbts.ui;
using mbts.ui.settings;
using mbts.ui.utility;
using mbts.utils;
using ProtoBuf;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reactive.Linq;
using OrderType = bts.api.orderman.CustomOrderDefinition.CustomOneofCase;
using PTOC = mbts.OrderRecordTuplePredicate.PredicateTypeOneofCase;
namespace mbts {
static class OrderRecordTuplePredicateVMFactory {
// TODO: uncomment the remaining cases when ready
public static Dictionary<PTOC, ITemplatedPropertyWrapperVM<OrderRecordTuplePredicate>> get_oneofs(IBus bus, OrdersModel orders_model) {
return new Dictionary<PTOC, ITemplatedPropertyWrapperVM<OrderRecordTuplePredicate>> {
{ PTOC.FilledEvent, wrap(rp => rp.filled_event, (rp, p) => rp.filled_event = p, p => p.predicate_type_case, OrderFilledEventPredicateVMFactory.get_oneofs(bus)) },
{ PTOC.CompletedEvent, wrap(rp => rp.completed_event, (rp, p) => rp.completed_event = p, p => p.predicate_type_case, OrderCompletedEventPredicateVMFactory.get_oneofs(bus)) },
{ PTOC.CanceledEvent, wrap(rp => rp.canceled_event, (rp, p) => rp.canceled_event = p, p => p.predicate_type_case, OrderCanceledEventPredicateVMFactory.get_oneofs(bus)) },
//{ PTOC.Security, wrap(rp => rp.security, (rp, p) => rp.security = p, p => p.predicate_type_case, SecurityCriteriaVMFactory.get_oneofs(bus)) },
//{ PTOC.Time, wrap(rp => rp.time_created, (rp, p) => rp.time_created = p, t => t.predicate_type_case, TimePredicateVMFactory.get_oneofs()) },
//{ PTOC.LastChange, wrap(rp => rp.last_change, (rp, p) => rp.last_change = p, t => t.predicate_type_case, TimePredicateVMFactory.get_oneofs()) },
//{ PTOC.User, wrap(rp => rp.user, (rp, p) => rp.user = p, p => p.predicate_type_case, DiscreteValuesPredicateVMFactory.get_oneofs<uint, uint, uint?, uint[], DiscreteUIntPredicate>(
// RXCollection.Create(orders_model.factory.subscribe_user_ids().Select(tups => tups.Select(convert_name_id))), id => id, id => id.Value, id => id, ids => ids, ids => ids.ToArray())) },
//{ PTOC.Account, wrap(rp => rp.account, (rp, p) => rp.account = p, p => p.predicate_type_case, DiscreteValuesPredicateVMFactory.get_oneofs<uint, uint, uint?, uint[], DiscreteUIntPredicate>(
// RXCollection.Create(orders_model.factory.subscribe_account_ids().Select(tups => tups.Select(convert_name_id))), id => id, id => id.Value, id => id, ids => ids, ids => ids.ToArray())) },
//{ PTOC.Exchange, wrap(rp => rp.exchange, (rp, p) => rp.exchange = p, p => p.predicate_type_case, DiscreteValuesPredicateVMFactory.get_oneofs_value_type<Venue, ExchangePredicate>(EnumHelper.get_values_except(Venue.Unset))) },
//{ PTOC.TimeInForce, wrap(rp => rp.time_in_force, (rp, p) => rp.time_in_force = p, p => p.predicate_type_case, DiscreteValuesPredicateVMFactory.get_oneofs_value_type<TimeInForce, TimeInForcePredicate>(EnumHelper.get_values_except(TimeInForce.Undefined))) },
//{ PTOC.Side, wrap(rp => rp.side, (rp, p) => rp.side = p, p => p.predicate_type_case, SidePredicateVMFactory.get_oneofs()) },
//{ PTOC.Price, wrap(rp => rp.price, (rp, p) => rp.price = p, p => p.predicate_type_case, DoublePredicateVMFactory.get_oneofs()) },
//{ PTOC.Size, wrap(rp => rp.quantity, (rp, p) => rp.quantity = p, p => p.predicate_type_case, UIntPredicateVMFactory.get_oneofs()) },
//{ PTOC.Filled, wrap(rp => rp.filled_quantity, (rp, p) => rp.filled_quantity = p, p => p.predicate_type_case, UIntPredicateVMFactory.get_oneofs()) },
//{ PTOC.AvgFilled, wrap(rp => rp.avg_price, (rp, p) => rp.avg_price = p, p => p.predicate_type_case, DoublePredicateVMFactory.get_oneofs()) },
//{ PTOC.LastPrice, wrap(rp => rp.last_price, (rp, p) => rp.last_price = p, p => p.predicate_type_case, DoublePredicateVMFactory.get_oneofs()) },
//{ PTOC.OrderType, wrap(rp => rp.order_type, (rp, p) => rp.order_type = p, p => p.predicate_type_case, DiscreteValuesPredicateVMFactory.get_oneofs_value_type<OrderType, OrderTypePredicate>(EnumHelper.get_values_except(OrderType.None))) },
//{ PTOC.SubType, wrap(rp => rp.order_sub_type, (rp, p) => rp.order_sub_type = p, p => p.predicate_type_case, DiscreteValuesPredicateVMFactory.get_oneofs_value_type<OrderSubType, OrderSubTypePredicate>(EnumHelper.get_values<OrderSubType>())) },
//{ PTOC.Status, wrap(rp => rp.order_status, (rp, p) => rp.order_status = p, p => p.predicate_type_case, DiscreteValuesPredicateVMFactory.get_oneofs_value_type<OrderStatus, OrderStatusPredicate>(EnumHelper.get_values<OrderStatus>())) },
//{ PTOC.LastMessage, wrap(rp => rp.last_message, (rp, p) => rp.last_message = p, p => p.predicate_type_case, StringPredicateVMFactory.get_oneofs()) },
//{ PTOC.SecurityKey, wrap(rp => rp.security_key, (rp, p) => rp.security_key = p, p => p.predicate_type_case, UIntPredicateVMFactory.get_oneofs()) },
//{ PTOC.OrderKey, wrap(rp => rp.order_key, (rp, p) => rp.order_key = p, p => p.predicate_type_case, UIntPredicateVMFactory.get_oneofs()) },
//{ PTOC.ParentKey, wrap(rp => rp.parent_key, (rp, p) => rp.parent_key = p, p => p.predicate_type_case, UIntPredicateVMFactory.get_oneofs()) },
};
//IViewValue<uint> convert_name_id((string name, uint id) tup) =>
// new ViewValueTuple<uint>(tup.id, tup.name);
ITemplatedPropertyWrapperVM<OrderRecordTuplePredicate> wrap<TChildPredicate, TChildPredicateOneof>(
Func<OrderRecordTuplePredicate, TChildPredicate> get,
Action<OrderRecordTuplePredicate, TChildPredicate> set,
Func<TChildPredicate, TChildPredicateOneof> key,
Dictionary<TChildPredicateOneof, ITemplatedPropertyWrapperVM<TChildPredicate>> oneofs) where TChildPredicateOneof : struct where TChildPredicate : new() =>
//
PredicateVMWrapper.wrap_child_oneof<OrderRecordTuplePredicate, TChildPredicate, TChildPredicateOneof>(get, set, key, oneofs);
}
}
[ProtoContract]
class OrderRecordTuplePredicate : IEquatable<OrderRecordTuplePredicate> {
SecurityPredicate _security;
SidePredicate _side;
DoublePredicate _price, _last_price, _avg_price;
UIntPredicate _quantity, _filled_quantity, _security_key, _order_key, _parent_key;
OrderStatusPredicate _order_status;
OrderTypePredicate _order_type;
OrderSubTypePredicate _order_sub_type;
TimePredicate _time_created, _last_change;
TimeInForcePredicate _time_in_force;
DiscreteUIntPredicate _account, _user;
StringPredicate _last_message;
ExchangePredicate _exchange;
OrderFilledEventPredicate _filled_event;
OrderCompletedEventPredicate _completed_event;
OrderCanceledEventPredicate _canceled_event;
public enum PredicateTypeOneofCase {
None,
[PredicateCase(is_toastable:false)]
Security,
[PredicateCase("Time created", is_toastable:false)]
Time,
[PredicateCase(is_toastable:false)]
LastChange,
[PredicateCase(is_toastable:false)]
User,
[PredicateCase(is_toastable:false)]
Account,
[PredicateCase(is_toastable:false)]
Exchange,
[PredicateCase(is_toastable:false)]
TimeInForce,
[PredicateCase(is_toastable:false)]
OrderType,
[PredicateCase("Order sub-type", is_toastable:false)]
SubType,
[PredicateCase(@"B\S", is_toastable:false)]
Side,
[PredicateCase(is_toastable:false)]
Size,
[PredicateCase(is_toastable:false)]
Price,
[PredicateCase("Filled qty", is_toastable:false)]
Filled,
[PredicateCase("Avg fill-price", is_toastable:false)]
AvgFilled,
[PredicateCase("Last fill-price", is_toastable:false)]
LastPrice,
[PredicateCase("Order status", is_toastable:false)]
Status,
[PredicateCase("Last message", is_toastable:false)]
LastMessage,
[PredicateCase(is_toastable:false)]
SecurityKey,
[PredicateCase(is_toastable:false)]
OrderKey,
[PredicateCase(is_toastable:false)]
ParentKey,
[PredicateCase("When order gets a fill", PredicateCategory.Event)]
FilledEvent,
[PredicateCase("When order is completed", PredicateCategory.Event)]
CompletedEvent,
[PredicateCase("When order is canceled", PredicateCategory.Event)]
CanceledEvent
}
[ProtoMember(1)]
public SecurityPredicate security { get => _security; set => _set(ref _security, value); }
[ProtoMember(2)]
public TimePredicate time_created { get => _time_created; set => _set(ref _time_created, value); }
[ProtoMember(3)]
public TimePredicate last_change { get => _last_change; set => _set(ref _last_change, value); }
[ProtoMember(4)]
public DiscreteUIntPredicate account { get => _account; set => _set(ref _account, value); }
[ProtoMember(5)]
public DiscreteUIntPredicate user { get => _user; set => _set(ref _user, value); }
[ProtoMember(6)]
public ExchangePredicate exchange { get => _exchange; set => _set(ref _exchange, value); }
[ProtoMember(7)]
public TimeInForcePredicate time_in_force { get => _time_in_force; set => _set(ref _time_in_force, value); }
[ProtoMember(8)]
public SidePredicate side { get => _side; set => _set(ref _side, value); }
[ProtoMember(9)]
public DoublePredicate price { get => _price; set => _set(ref _price, value); }
[ProtoMember(10)]
public UIntPredicate quantity { get => _quantity; set => _set(ref _quantity, value); }
[ProtoMember(11)]
public UIntPredicate filled_quantity { get => _filled_quantity; set => _set(ref _filled_quantity, value); }
[ProtoMember(12)]
public DoublePredicate last_price { get => _last_price; set => _set(ref _last_price, value); }
[ProtoMember(13)]
public DoublePredicate avg_price { get => _avg_price; set => _set(ref _avg_price, value); }
[ProtoMember(14)]
public OrderTypePredicate order_type { get => _order_type; set => _set(ref _order_type, value); }
[ProtoMember(15)]
public OrderSubTypePredicate order_sub_type { get => _order_sub_type; set => _set(ref _order_sub_type, value); }
[ProtoMember(16)]
public OrderStatusPredicate order_status { get => _order_status; set => _set(ref _order_status, value); }
[ProtoMember(17)]
public StringPredicate last_message { get => _last_message; set => _set(ref _last_message, value); }
[ProtoMember(18)]
public UIntPredicate security_key { get => _security_key; set => _set(ref _security_key, value); }
[ProtoMember(19)]
public UIntPredicate order_key { get => _order_key; set => _set(ref _order_key, value); }
[ProtoMember(20)]
public UIntPredicate parent_key { get => _parent_key; set => _set(ref _parent_key, value); }
[ProtoMember(21)]
public OrderFilledEventPredicate filled_event { get => _filled_event; set => _set(ref _filled_event, value); }
[ProtoMember(22)]
public OrderCompletedEventPredicate completed_event { get => _completed_event; set => _set(ref _completed_event, value); }
[ProtoMember(23)]
public OrderCanceledEventPredicate canceled_event { get => _canceled_event; set => _set(ref _canceled_event, value); }
[ProtoMember(24)]
public bool is_toast_enabled { get; set; }
public PTOC predicate_type_case {
get {
if (_security != null) return PTOC.Security;
if (_time_created != null) return PTOC.Time;
if (_last_change != null) return PTOC.LastChange;
if (_user != null) return PTOC.User;
if (_account != null) return PTOC.Account;
if (_exchange != null) return PTOC.Exchange;
if (_time_in_force != null) return PTOC.TimeInForce;
if (_order_type != null) return PTOC.OrderType;
if (_order_sub_type != null) return PTOC.SubType;
if (_side != null) return PTOC.Side;
if (_quantity != null) return PTOC.Side;
if (_price != null) return PTOC.Price;
if (_filled_quantity != null) return PTOC.Filled;
if (_avg_price != null) return PTOC.AvgFilled;
if (_last_price != null) return PTOC.LastPrice;
if (_order_status != null) return PTOC.Status;
if (_last_message != null) return PTOC.LastMessage;
if (_security_key != null) return PTOC.SecurityKey;
if (_order_key != null) return PTOC.OrderKey;
if (_parent_key != null) return PTOC.ParentKey;
if (_filled_event != null) return PTOC.FilledEvent;
if (_completed_event != null) return PTOC.CompletedEvent;
if (_canceled_event != null) return PTOC.CanceledEvent;
return PTOC.None;
}
}
public IPredicate<OrderSecurity> create_predicate(INotificationServiceDataCache data_cache) {
switch (predicate_type_case) {
case PTOC.Security: return wrap(_security.create(), r => r.security ?? SecurityDataHelper.Defaults.SecurityImmutable);
case PTOC.Time: return wrap(_time_created.create(), r => r.order.created());
case PTOC.LastChange: return wrap(_last_change.create(), r => r.order.last_change());
case PTOC.User: return wrap(_user.create(), r => r.order.user_id());
case PTOC.Account: return wrap(_account.create(), r => r.order.account_id());
case PTOC.Exchange: return wrap(_exchange.create(), r => r.security.exchange_or_default());
case PTOC.TimeInForce: return wrap(_time_in_force.create(), r => r.order.time_in_force());
case PTOC.OrderType: return wrap(_order_type.create(), r => r.order.order_type());
case PTOC.SubType: return wrap(_order_sub_type.create(), r => r.order.sub_type());
case PTOC.Side: return wrap(_side.create(), r => r.order.side());
case PTOC.Size: return wrap(_quantity.create(), r => r.order.quantity());
case PTOC.Price: return wrap(_price.create(), r => r.order.price());
case PTOC.Filled: return wrap(_filled_quantity.create(), r => r.order.filled());
case PTOC.AvgFilled: return wrap(_avg_price.create(), r => r.order.avg_price());
case PTOC.LastPrice: return wrap(_last_price.create(), r => r.order.last_price());
case PTOC.Status: return wrap(_order_status.create(), r => r.order.status());
case PTOC.LastMessage: return wrap(_last_message.create(), r => r.order.last_msg());
case PTOC.SecurityKey: return wrap(_security_key.create(), r => r.order.security_key());
case PTOC.OrderKey: return wrap(_order_key.create(), r => r.order.Key);
case PTOC.ParentKey: return wrap(_parent_key.create(), r => r.order.ParentKey);
case PTOC.FilledEvent: return _filled_event.create_predicate(data_cache);
case PTOC.CompletedEvent: return _completed_event.create_predicate(data_cache);
case PTOC.CanceledEvent: return _canceled_event.create(data_cache);
default: return null;
}
//
IPredicate<OrderSecurity> wrap<T>(IPredicate<T> trigger, Func<OrderSecurity, T> select) =>
trigger.wrap<OrderSecurity, T>(select);
}
public INotificationPredicate<OrderSecurity> create_notification_predicate(INotificationServiceDataCache notification_service_data_cache) {
if (!is_toast_enabled)
return null;
switch (predicate_type_case) {
case PTOC.FilledEvent: return _filled_event.create_toast(notification_service_data_cache);
case PTOC.CompletedEvent: return _completed_event.create_toast(notification_service_data_cache);
case PTOC.CanceledEvent: return _canceled_event.create_toast(notification_service_data_cache);
default: return null;
}
}
public bool Equals(OrderRecordTuplePredicate other) {
if (other == null)
return false;
PTOC ptoc = predicate_type_case;
if (ptoc != other.predicate_type_case)
return false;
switch (ptoc) {
case PTOC.Security: return _security.Equals(other._security);
case PTOC.Time: return _time_created.Equals(other._time_created);
case PTOC.LastChange: return _last_change.Equals(other._last_change);
case PTOC.User: return _user.Equals(other._user);
case PTOC.Account: return _account.Equals(other._account);
case PTOC.Exchange: return _exchange.Equals(other._exchange);
case PTOC.TimeInForce: return _time_in_force.Equals(other._time_in_force);
case PTOC.OrderType: return _order_type.Equals(other._order_type);
case PTOC.SubType: return _order_sub_type.Equals(other._order_sub_type);
case PTOC.Side: return _side.Equals(other._side);
case PTOC.Price: return _price.Equals(other._price);
case PTOC.Size: return _quantity.Equals(other._quantity);
case PTOC.Filled: return _filled_quantity.Equals(other._filled_quantity);
case PTOC.LastPrice: return _last_price.Equals(other._last_price);
case PTOC.AvgFilled: return _avg_price.Equals(other._avg_price);
case PTOC.Status: return _order_status.Equals(other._order_status);
case PTOC.LastMessage: return _last_message.Equals(other._last_message);
case PTOC.SecurityKey: return _security_key.Equals(other._security_key);
case PTOC.OrderKey: return _order_key.Equals(other._order_key);
case PTOC.ParentKey: return _parent_key.Equals(other._parent_key);
case PTOC.FilledEvent: return _filled_event.Equals(other._filled_event);
case PTOC.CompletedEvent: return _completed_event.Equals(other._completed_event);
case PTOC.CanceledEvent: return _canceled_event.Equals(other._canceled_event);
case PTOC.None: return true;
default: throw ExceptionHelper.unexpected_oneof_case(ptoc);
}
}
public override bool Equals(object obj) => Equals(obj as OrderRecordTuplePredicate);
public override int GetHashCode() {
PTOC ptoc = predicate_type_case;
int raw_hash;
switch (ptoc) {
case PTOC.Security: raw_hash = _security.GetHashCode(); break;
case PTOC.Time: raw_hash = _time_created.GetHashCode(); break;
case PTOC.LastChange: raw_hash = _last_change.GetHashCode(); break;
case PTOC.User: raw_hash = _user.GetHashCode(); break;
case PTOC.Account: raw_hash = _account.GetHashCode(); break;
case PTOC.Exchange: raw_hash = _exchange.GetHashCode(); break;
case PTOC.TimeInForce: raw_hash = _time_in_force.GetHashCode(); break;
case PTOC.OrderType: raw_hash = _order_type.GetHashCode(); break;
case PTOC.SubType: raw_hash = _order_sub_type.GetHashCode(); break;
case PTOC.Side: raw_hash = _side.GetHashCode(); break;
case PTOC.Price: raw_hash = _price.GetHashCode(); break;
case PTOC.Size: raw_hash = _quantity.GetHashCode(); break;
case PTOC.Filled: raw_hash = _filled_quantity.GetHashCode(); break;
case PTOC.LastPrice: raw_hash = _last_price.GetHashCode(); break;
case PTOC.AvgFilled: raw_hash = _avg_price.GetHashCode(); break;
case PTOC.Status: raw_hash = _order_status.GetHashCode(); break;
case PTOC.LastMessage: raw_hash = _last_message.GetHashCode(); break;
case PTOC.SecurityKey: raw_hash = _security_key.GetHashCode(); break;
case PTOC.OrderKey: raw_hash = _order_key.GetHashCode(); break;
case PTOC.ParentKey: raw_hash = _parent_key.GetHashCode(); break;
case PTOC.FilledEvent: raw_hash = _filled_event.GetHashCode(); break;
case PTOC.CompletedEvent: raw_hash = _completed_event.GetHashCode(); break;
case PTOC.CanceledEvent: raw_hash = _canceled_event.GetHashCode(); break;
case PTOC.None: raw_hash = 0; break;
default: throw ExceptionHelper.unexpected_oneof_case(ptoc);
}
return EqualityComparer.phase_hash(raw_hash, (int)ptoc);
}
static string _get_order_placed_toast_msg(OrderSecurity order) =>
$"Order Sent: {order.security.display_name()} {order.order.short_description(order.security.spec_or_default())}";
void _set<T>(ref T field, T value) {
if (value != null) {
_security = null;
_time_created = null;
_last_change = null;
_exchange = null;
_account = null;
_user = null;
_time_in_force = null;
_order_sub_type = null;
_order_type = null;
_side = null;
_price = null;
_quantity = null;
_filled_quantity = null;
_last_price = null;
_avg_price = null;
_order_status = null;
_last_message = null;
_security_key = null;
_order_key = null;
_parent_key = null;
_filled_event = null;
_completed_event = null;
_canceled_event = null;
}
field = value;
}
}
[ProtoContract]
class OrderRecordTuplePredicateAnimations : IPredicateAnimationsData<OrderSecurity, OrderRecordTuplePredicate> {
[ProtoMember(1)]
OrderRecordTuplePredicate _predicate;
[ProtoMember(2)]
List<CellAnimation> _cell_animations;
[ProtoMember(3)]
List<RowAnimation> _row_animations;
[ProtoMember(4)]
List<SoundNotification> _sound_animations;
public OrderRecordTuplePredicateAnimations() { }
public OrderRecordTuplePredicateAnimations(OrderRecordTuplePredicate predicate, IEnumerable<CellAnimation> cell_animations, IEnumerable<RowAnimation> row_animations, IEnumerable<SoundNotification> sound_animations) {
_predicate = predicate;
_cell_animations = new List<CellAnimation>(cell_animations);
_row_animations = new List<RowAnimation> ( row_animations );
_sound_animations = new List<SoundNotification> ( sound_animations );
}
public OrderRecordTuplePredicate predicate_data => _predicate;
public IReadOnlyList<CellAnimation> cell_animations => _cell_animations ?? (_cell_animations = new List<CellAnimation>());
public IReadOnlyList<RowAnimation> row_animations => _row_animations ?? (_row_animations = new List<RowAnimation>());
public IReadOnlyList<SoundNotification> sound_notifications => _sound_animations ?? (_sound_animations = new List<SoundNotification>());
}
}