Merged synthetic-importer into master

This commit is contained in:
Taha Afzal committed 2019-12-18 10:03:45 -05:00
commit 23cffc0630
56 files changed
+2924 -76

No files matched your search

@@ -4,43 +4,112 @@ using mbts;
using mbts.spark;
using mbts.ui;
using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.ComponentModel.Composition;
using System.Linq;
using System.Reactive.Linq;
using System.Threading;
using System.Windows;
namespace bts {
[Export, Export(typeof(IShellDaemon))]
class DeleteSyntheticDaemon : IShellDaemon, IDisposable {
// request_id is noted in the series of log messages that occur during a particular delete op.
static int _request_id = 1;
readonly OrdersModel _orders_model;
readonly ErrorReporter _error_reporter;
IReadOnlyDictionary<uint, ExecutionStrategyImmutable> _strategy_map =
DictionaryHelper.empty<uint, ExecutionStrategyImmutable>();
IDisposable _dispose;
[ImportingConstructor]
public DeleteSyntheticDaemon(IBus bus, OrdersModel orders_model, ErrorReporter error_reporter) {
_orders_model = orders_model;
_error_reporter = error_reporter;
_dispose = bus.subscribe(SparkTags.SyntheticDeleteTag)
.OnDispatcher()
.Subscribe(_delete_synthetic);
_dispose = Disposable.Create(
bus.subscribe(SparkTags.SyntheticDeleteTag).Subscribe(_delete_synthetic),
orders_model.spreader.strategy.Subscribe(map => _strategy_map = map));
}
public void Dispose() =>
Disposable.dispose(ref _dispose);
async void _delete_synthetic(uint id) {
var (orders, orders_success) = await _orders_model.on_orders.FirstAsyncTask(SparkUtils.DefaultTimeOut);
async void _delete_synthetic(IImmutableSet<uint> keys) {
var log = new LoggerContext(Log.Ui, $"Synthetic Delete Req {unchecked(Interlocked.Increment(ref _request_id))} - ", null);
if (keys.is_null_or_empty()) {
log.warn("received empty delete request (no securities specified).");
return;
}
log.info($"received request to delete the following {keys.Count} securities: {string.Join(", ", keys)}");
var (orders, orders_success) = await _orders_model.security_order_groups.FirstAsyncTask(SparkUtils.DefaultTimeOut);
if (!orders_success) {
_error_reporter.report_error($"Unable to delete synthetic security ({id}): unable to determine whether or not security ({id}) has working orders (deletion is not permitted while there are working orders).");
Log.Ui.warn($"Ignoring request to delete synthetic security ({id}) because the orders lookup timed out (must confirm no working orders).");
} else if (orders.state.Values.Any(o => o.order.Def.SecurityKey == id && o.order.is_non_terminal())) {
Log.Ui.warn($"Ignoring request to delete synthetic security ({id}) because non-terminal-orders were detected.");
var msg = "Unable to delete synthetic securities: " +
$"timed out waiting for orders table (must verify that a synthetic security does not have any working orders before it can be deleted).";
_error_reporter.report_error(msg);
log.warn(msg);
} else {
ExecutionStrategyImmutable? strategy = await _orders_model.spreader.lookup_strategy_async(id);
if (strategy.HasValue) {
ExecutionStrategyImmutable deleted_strategy = strategy.Value.with(deleted: true);
await _orders_model.spreader.save_strategy(id, deleted_strategy);
var working_orders = new List<uint>();
var missing_strategies = new List<uint>();
var items = new List<(uint key, ExecutionStrategyImmutable strategy)>();
var temp_strats = _strategy_map;
foreach (var k in keys) {
if (orders.state.TryGetValue(k, out var sec_group) && sec_group.table.state.Values.Any(tup => tup.order.is_active())) {
working_orders.Add(k);
} else if (!temp_strats.TryGetValue(k, out var strat)) {
missing_strategies.Add(k);
} else {
items.Add((k, strat.with(deleted: true)));
}
}
var lines = new List<string>();
if (working_orders.Count > 0) {
lines.Add($"skipping {working_orders.Count} securities because they have working orders.");
}
if (missing_strategies.Count > 0) {
lines.Add($"skipping {missing_strategies.Count} securities because their execution strategies were not discovered.");
}
if (lines.Count > 0)
log.warn(string.Join("; ", lines));
var errors = await _orders_model.spreader.save_strategies(items);
int error_count = errors.Count(e => !string.IsNullOrEmpty(e));
log.info($"{items.Count - error_count}/{items.Count} attempted deletes were successful (skipped {working_orders.Count + missing_strategies.Count}).");
// display results to user
const string dialog_title = "Synthetic Deletion";
string display_msg;
MessageBoxImage icon = MessageBoxImage.None;
if (keys.Count > 1) {
if (error_count == 0 && working_orders.Count == 0 && missing_strategies.Count == 0) {
display_msg = $"Synthetic securities have been deleted.";
icon = MessageBoxImage.Information;
} else {
display_msg = $"{keys.Count - error_count - working_orders.Count - missing_strategies.Count}/{keys.Count} securities were successfully deleted.";
icon = MessageBoxImage.Error;
}
} else {
if (error_count == 0 && working_orders.Count == 0 && missing_strategies.Count == 0) {
display_msg = "Synthetic security has been deleted.";
icon = MessageBoxImage.Information;
} else {
string reason;
if (error_count > 0) {
reason = errors[0];
} else if (missing_strategies.Count > 0) {
reason = "did not find execution strategy.";
} else if (working_orders.Count > 0) {
reason = "working orders detected.";
} else {
// unexpected code path
reason = "unknown error.";
}
icon = MessageBoxImage.Error;
display_msg = $"Unable to delete synthetic security: " + reason;
}
}
BTSMessageBox.Show(display_msg, dialog_title, BTSMessageBoxButtons.OK, icon);
}
}
}
}
}
+44 -1
View File
@@ -1,12 +1,15 @@
using bts.api;
using bts.api.core;
using bts.support;
using bts.utils;
using mbts;
using mbts.spark;
using mbts.ui;
using System;
using System.Collections.Generic;
using System.ComponentModel.Composition;
using System.Reactive.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Threading;
@@ -164,5 +167,45 @@ namespace bts.spark {
void _report_error(string msg) =>
error_reporter.report_error($"Error {desc}: {msg}", AlgoStudioWindow.NAME, MessageBoxImage.Warning);
}
public static async Task<(TResult result, string error_msg)[]> safe_execute_batch<T, TResult>(
this ErrorReporter error_reporter,
IEnumerable<Task<T>> execute,
Func<T, (TResult result, string error_msg)> result_selector,
string desc,
string title) {
//
try {
var results = await Task.WhenAll(execute as Task<T>[] ?? ArrayHelper.clone_optimized(execute));
var result_values = new (TResult, string)[results.Length];
StringBuilder error_bd = null;
for (int i = 0; i < results.Length; i++) {
var r = results[i];
var (result, error) = result_selector(r);
if (!string.IsNullOrEmpty(error)) {
if (error_bd == null) {
error_bd = new StringBuilder();
} else {
error_bd.AppendLine();
}
error_bd.Append(error);
}
result_values[i] = (result, error);
}
if (error_bd != null) {
var error_msg = error_bd.ToString();
if (!string.IsNullOrEmpty(error_msg))
_report_error(error_msg);
}
return result_values;
}
catch (Exception ex) {
_report_error(ex.ToString());
}
return null;
//
void _report_error(string msg) =>
error_reporter.report_error($"Error {desc}: {msg}", title, MessageBoxImage.Warning);
}
}
}
}
+2 -2
View File
@@ -39,7 +39,7 @@ namespace bts {
_relay.set_token(_token.Value);
_dispose.Add(
_ss.Value.subscribei_metadata()
.Select(upd => upd.all.ToDictionary(i => i.SecurityKey, i => i.Strategy))
.Select(upd => upd.all.Where(i => i.HasStrategy).ToDictionary(i => i.SecurityKey, i => i.Strategy))
.Subscribe(t => {
var deleted_synthetic_keys = new HashSet<uint>(t.Where(kv => kv.Value.Deleted).Select(kv => kv.Key));
// add back 'undeleted' synthetics
@@ -64,4 +64,4 @@ namespace bts {
Task.Run(run);
}
}
}
}
+6 -1
View File
@@ -1,4 +1,5 @@
using bts;
using mbts.ui.dpi;
using System;
using System.Collections.Generic;
using System.Linq;
@@ -55,7 +56,9 @@ namespace mbts.ui {
StarGeometryKey = nameof(StarGeometryKey),
ToolsGeometryKey = nameof(ToolsGeometryKey),
TrashGeometryKey = nameof(TrashGeometryKey),
UndoCircularGeometryKey = nameof(UndoCircularGeometryKey);
UndoCircularGeometryKey = nameof(UndoCircularGeometryKey),
WarningExclamationGeometryKey = nameof(WarningExclamationGeometryKey),
WarningGeometryKey = nameof(WarningGeometryKey);
public static Geometry PlayGeometry => Geometry.Parse(get_geometric_path(PlayGeometryKey).FirstOrDefault() ?? string.Empty);
@@ -190,6 +193,8 @@ namespace mbts.ui {
public static ImageSource Tetris { get { return load_resource_and_freeze("Tetris"); } }
public static ImageSource Tools => create_icon(ToolsGeometryKey);
public static ImageSource Trash => create_icon(TrashGeometryKey);
public static ImageSource Warning => create_icon(WarningGeometryKey, Brushes.IndianRed);
public static ImageSource WarningExclamation => create_icon(WarningExclamationGeometryKey, Brushes.IndianRed);
public static ImageSource UndoCircular => create_icon(UndoCircularGeometryKey);
public static ImageSource ViewSettings => load_resource_and_freeze("ViewSettings");
public static ImageSource Wrench { get { return load_resource_and_freeze("Wrench"); } }
+12
View File
@@ -363,6 +363,18 @@
c-84.15,0-153-68.85-153-153h-51c0,112.2,91.8,204,204,204s204-91.8,204-204S360.825,89.25,248.625,89.25z
</sys:String>
<sys:String x:Key="{x:Static mbts:Icons.WarningExclamationGeometryKey}">
M15.998999,17.988002C16.551,17.988002 16.999,18.437009 16.999,18.990018 16.999,19.543027 16.551,19.992034 15.998999,19.992034 15.446999,19.992034 14.998999,19.543027 14.998999,18.990018 14.998999,18.437009 15.446999,17.988002 15.998999,17.988002z
M15.998999,8.0630169C16.552,8.0630169,16.999,8.5110159,16.999,9.0650149L16.999,16.167001C16.999,16.721 16.552,17.168998 15.998999,17.168998 15.446,17.168998 14.998999,16.721 14.998999,16.167001L14.998999,9.0650149C14.998999,8.5110159,15.446,8.0630169,15.998999,8.0630169z
</sys:String>
<sys:String x:Key="{x:Static mbts:Icons.WarningGeometryKey}">
M15.998999,17.988002C16.551,17.988002 16.999,18.437009 16.999,18.990018 16.999,19.543027 16.551,19.992034 15.998999,19.992034 15.446999,19.992034 14.998999,19.543027 14.998999,18.990018 14.998999,18.437009 15.446999,17.988002 15.998999,17.988002z
M15.998999,8.0630169C16.552,8.0630169,16.999,8.5110159,16.999,9.0650149L16.999,16.167001C16.999,16.721 16.552,17.168998 15.998999,17.168998 15.446,17.168998 14.998999,16.721 14.998999,16.167001L14.998999,9.0650149C14.998999,8.5110159,15.446,8.0630169,15.998999,8.0630169z
M15.999277,2.3337629L2.3830507,22.996989 29.615442,22.996989z
M15.999513,0C16.50052,-3.8678991E-07,17.001274,0.21826346,17.288297,0.65479128L31.74151,22.585975C32.057495,23.064982 32.084472,23.677966 31.812494,24.184989 31.541494,24.687009 31.02049,24.999999 30.450475,24.999999L1.5480773,24.999999C0.97903845,24.999999 0.45705819,24.687009 0.18703459,24.184989 -0.085979476,23.677966 -0.057963934,23.064982 0.25704309,22.585975L14.709219,0.65479128C14.997247,0.21826346,15.498506,-3.8678991E-07,15.999513,0z
</sys:String>
<!--
'y' for equilateral triangle of side length x:
(x/2)^2 + Y^2 = x^2
@@ -0,0 +1,25 @@
<UserControl
x:Class="bts.shell.spreader.ContractLegTypeView"
x:ClassModifier="internal"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:spr="clr-namespace:bts.shell.spreader"
>
<ItemsControl ItemsSource="{Binding Controller.flags, RelativeSource={RelativeSource AncestorType=spr:ContractLegTypeView}}">
<ItemsControl.ItemsPanel>
<ItemsPanelTemplate>
<UniformGrid Rows="1"/>
</ItemsPanelTemplate>
</ItemsControl.ItemsPanel>
<ItemsControl.ItemTemplate>
<DataTemplate>
<CheckBox
Margin="2"
IsChecked="{Binding is_selected}"
Content="{Binding value, Converter={x:Static spr:ContractLegTypeView.LegTypeShortDescConverter}}"
ToolTip="{Binding value, Converter={x:Static spr:ContractLegTypeView.LegTypeLongDescConverter}}"
/>
</DataTemplate>
</ItemsControl.ItemTemplate>
</ItemsControl>
</UserControl>
@@ -0,0 +1,104 @@
using bts.collections;
using mbts;
using mbts.ui;
using mbts.ui.converters;
using mbts.ui.shell;
using mbts.ui.utility;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
namespace bts.shell.spreader {
static class EnumFlagItemsVM {
public static EnumFlagItemsVM<T> create<T>(IEnumerable<T> flags) where T : struct =>
new EnumFlagItemsVM<T>(flags);
}
class EnumFlagItemsVM<T> : ViewModelBase where T : struct {
readonly ObservableCollection<SelectableItemVM<T>> _flags = new ObservableCollection<SelectableItemVM<T>>();
bool _is_busy;
T _result;
public EnumFlagItemsVM()
: this(EnumHelper.get_values<T>()) { }
public EnumFlagItemsVM(IEnumerable<T> flags) {
this.flags = ObservableAutoWrapper.create_read_only_wrapper(_flags);
_flags.AddRange(flags.Select(f => new SelectableItemVM<T>(f)));
foreach (var vm in _flags) {
vm.is_selected_changed += on_is_selected_changed;
void on_is_selected_changed(bool value) {
if (!_is_busy) {
_is_busy = true;
result = value ?
EnumHelper.add_flags(result, vm.value) :
EnumHelper.remove_flags(result, vm.value);
_is_busy = false;
}
}
}
}
public event Action result_changed;
public IReadOnlyObservableCollection<SelectableItemVM<T>> flags { get; }
public T result {
get => _result;
set {
if (!EqualityComparer<T>.Default.Equals(_result, value)) {
_result = value;
if (!_is_busy) {
_is_busy = true;
for (int i = 0; i < flags.Count; i++)
flags[i].is_selected = EnumHelper.has_flags(value, flags[i].value);
_is_busy = false;
}
result_changed?.Invoke();
RaisePropertyChanged();
}
}
}
}
/// <summary>
/// Interaction logic for ContractLegTypeView.xaml
/// </summary>
partial class ContractLegTypeView : UserControl {
public static IValueConverter LegTypeShortDescConverter =>
ValueConverter.create<ContractLegType, string>(SyntheticSecurityParser.display_name);
public static IValueConverter LegTypeLongDescConverter =>
ValueConverter.create<ContractLegType, string>(lt =>
string.Join(" & ", EnumHelper.split_flags(lt).Select(f => EnumHelper.get_display_name(f))));
public ContractLegTypeView() {
InitializeComponent();
Controller.result = Value;
Controller.result_changed += _on_controller_result_changed;
}
public static readonly DependencyProperty ValueProperty =
WPFHelper.create_dp<ContractLegType, ContractLegTypeView>(
nameof(Value),
FrameworkPropertyMetadataOptions.BindsTwoWayByDefault,
(o, v) => {
o.Controller.result_changed -= o._on_controller_result_changed;
o.Controller.result = v;
o.Controller.result_changed += o._on_controller_result_changed;
});
public ContractLegType Value {
get => (ContractLegType)GetValue(ValueProperty);
set => SetValue(ValueProperty, value);
}
public EnumFlagItemsVM<ContractLegType> Controller { get; } = EnumFlagItemsVM.create(EnumHelper.get_values_except(ContractLegType.None));
void _on_controller_result_changed() =>
SetCurrentValue(ValueProperty, Controller.result);
}
}
@@ -0,0 +1,47 @@
<Window
x:Class="bts.shell.spreader.SyntheticImportConflictsDialog"
x:ClassModifier="internal"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:u="clr-namespace:mbts.ui"
xmlns:c="clr-namespace:mbts.ui.controls"
xmlns:cv="clr-namespace:mbts.ui.converters"
xmlns:spr="clr-namespace:bts.shell.spreader"
u:WindowStyle.AllowResize="True"
u:WindowStyle.SizeToContent="WidthAndHeight"
u:WindowStyle.TitleContent="Import Synthetics Conflicts"
Style="{StaticResource BTSDialogTitleTemplate}"
>
<Window.MaxHeight>
<Binding Path="SizeToContent" RelativeSource="{RelativeSource Self}">
<Binding.Converter>
<cv:WindowMaxHeightConverter SizeToContentThreshold="{u:DPIDouble 700}"/>
</Binding.Converter>
</Binding>
</Window.MaxHeight>
<u:WindowStyle.TitleContentTemplate>
<DataTemplate>
<StackPanel Orientation="Horizontal" HorizontalAlignment="Left">
<Image Height="12" Margin="5,2" Source="{x:Static u:Icons.Import}"/>
<TextBlock Margin="4,0,0,0" Text="{Binding}"/>
</StackPanel>
</DataTemplate>
</u:WindowStyle.TitleContentTemplate>
<Window.Content>
<Grid>
<Grid.RowDefinitions>
<RowDefinition Height="*"/>
<RowDefinition Height="Auto"/>
</Grid.RowDefinitions>
<spr:SyntheticImportConflictsView Margin="12,10,12,8"/>
<c:DialogSkirt Grid.Row="1">
<c:DialogSkirt.RightItems>
<x:Array Type="{x:Type Button}">
<Button Command="{Binding ok_cmd}">Continue</Button>
<Button Command="{Binding cancel_cmd}" IsCancel="True">Cancel</Button>
</x:Array>
</c:DialogSkirt.RightItems>
</c:DialogSkirt>
</Grid>
</Window.Content>
</Window>
@@ -0,0 +1,11 @@
using System.Windows;
namespace bts.shell.spreader {
/// <summary>
/// Interaction logic for SyntheticImportConflictsDialog.xaml
/// </summary>
partial class SyntheticImportConflictsDialog : Window {
public SyntheticImportConflictsDialog() =>
InitializeComponent();
}
}
@@ -0,0 +1,101 @@
using bts.api;
using bts.collections;
using bts.utils;
using mbts;
using mbts.spark;
using mbts.ui;
using mbts.user.settings;
using System.Collections.Generic;
using System.Linq;
namespace bts.shell.spreader {
readonly struct SyntheticComponent {
public readonly SyntheticContractComponent type;
public readonly int leg_index;
public SyntheticComponent(SyntheticContractComponent type, int leg_index) {
this.type = type;
this.leg_index = leg_index;
}
}
class SyntheticImportConflictsVM : ImportConflictsVM<(SyntheticImportRowVM synth, ContractLegVM leg), SyntheticImportRowVM, SyntheticContractComponent>, IRequestViewClose {
IReadOnlyDictionary<uint, SecurityMD> _security_map = DictionaryHelper.empty<uint, SecurityMD>();
public SyntheticImportConflictsVM(int num_synthetics)
: base(num_synthetics, tup => tup.synth) { }
// misc items sources
public IReadOnlyDictionary<uint, SecurityMD> security_map {
get => _security_map;
set {
if (!ReferenceEquals(_security_map, value)) {
_security_map = value;
_resolve_securities();
RaisePropertyChanged();
}
}
}
void _resolve_securities() {
if (_security_map == null)
return;
var reverse_lookup = SyntheticSecurityParser.reverse_lookup(MappedDictionary.create(_security_map, v => v.security.ToString()));
foreach (var r in conflicts) {
if (r.component == SyntheticContractComponent.Security && r.has_error) {
var id = reverse_lookup(r.text);
if (id != 0 && _security_map.TryGetValue(id, out var smd))
r.value = smd.security;
}
}
}
}
class SyntheticImportConflictRowVM : ImportConflictRowVM<(SyntheticImportRowVM synth, ContractLegVM leg), SyntheticContractComponent>, ITemplateSelectorKey {
public SyntheticImportConflictRowVM(
SyntheticContractComponent component,
string text,
IReadOnlyCollection<(SyntheticImportRowVM synth, ContractLegVM leg)> affected_parts,
object error_value,
object value)
: base(component, text, affected_parts, error_value, value, affected_parts.DistinctOn(tup => tup.synth).Count()) { }
public override void on_conflicts_resolved() {
if (has_error)
return;
foreach (var (synth, leg) in affected_parts) {
switch (component) {
case SyntheticContractComponent.Name:
if (value is string str)
synth.name = str;
break;
case SyntheticContractComponent.TickSize:
if (value is double ts && ts.IsNonZero()) {
synth.tick_factors = TickUtils.get_regional_ticks(new ContractSpecificationImmutable(new ContractSpecification {
LowTick = ts,
HighTick = ts
})).low_tick;
} else if (value is TickFactors tf && tf.is_valid())
synth.tick_factors = tf;
break;
case SyntheticContractComponent.Security:
if (value is SecurityImmutable sec && sec.is_exchange_security())
leg.security = sec;
break;
case SyntheticContractComponent.PriceMultiplier:
if (value is double pm && pm.IsNonZero())
leg.price_multiplier = pm;
break;
case SyntheticContractComponent.Quantity:
if (value is double q && q.IsNonZero())
leg.quantity = q;
break;
case SyntheticContractComponent.LegType:
if (value is ContractLegType lt)
leg.leg_type = lt;
break;
}
}
}
}
}
@@ -0,0 +1,199 @@
<UserControl
x:Class="bts.shell.spreader.SyntheticImportConflictsView"
x:ClassModifier="internal"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:u="clr-namespace:mbts.ui"
xmlns:c="clr-namespace:mbts.ui.controls"
xmlns:cv="clr-namespace:mbts.ui.converters"
xmlns:spr="clr-namespace:bts.shell.spreader"
MinWidth="400"
>
<UserControl.Resources>
<Style x:Key="VerticallyCenteredText" TargetType="TextBlock">
<Setter Property="VerticalAlignment" Value="Center"/>
</Style>
<!--Value Cell Template Selector-->
<u:KeyedTemplateSelector x:Key="ValueCellTemplateSelector">
<u:KeyedTemplateSelector.Default>
<DataTemplate>
<TextBlock Text="{Binding value}" VerticalAlignment="Center"/>
</DataTemplate>
</u:KeyedTemplateSelector.Default>
<u:TemplateSelectorKeyValue Key="PriceMultiplier">
<DataTemplate>
<TextBlock Text="{Binding value, Converter={StaticResource DoubleTextConverter}}" VerticalAlignment="Center"/>
</DataTemplate>
</u:TemplateSelectorKeyValue>
<u:TemplateSelectorKeyValue Key="Quantity">
<DataTemplate>
<TextBlock Text="{Binding value, Converter={StaticResource DoubleTextConverter}}" VerticalAlignment="Center"/>
</DataTemplate>
</u:TemplateSelectorKeyValue>
<u:TemplateSelectorKeyValue Key="Security">
<DataTemplate>
<TextBlock Text="{Binding value, Converter={x:Static cv:ValueConverters.SecuritySelectorText}}"/>
</DataTemplate>
</u:TemplateSelectorKeyValue>
<u:TemplateSelectorKeyValue Key="LegType">
<DataTemplate>
<TextBlock Text="{Binding value, Converter={x:Static spr:ContractLegTypeView.LegTypeShortDescConverter}}">
<TextBlock.ToolTip>
<TextBlock>
<Run Text="{Binding value, Converter={x:Static spr:ContractLegTypeView.LegTypeLongDescConverter}}"/>
<LineBreak/>
<Run Text="Q = Quote"/>
<LineBreak/>
<Run Text="H = Hedge"/>
<LineBreak/>
<Run Text="N = None"/>
</TextBlock>
</TextBlock.ToolTip>
</TextBlock>
</DataTemplate>
</u:TemplateSelectorKeyValue>
</u:KeyedTemplateSelector>
<!--Value Cell Editing Template Selector-->
<u:KeyedTemplateSelector x:Key="ValueCellEditingTemplateSelector">
<u:TemplateSelectorKeyValue Key="Security">
<DataTemplate>
<c:ContractPickerPopup
HorizontalAlignment="Stretch"
VerticalAlignment="Stretch"
CloseOnCancel="True"
CloseOnOK="True"
Header="{Binding value, Converter={x:Static cv:ValueConverters.SecuritySelectorText}}"
IsEditMode="False"
IsLazy="True"
SecurityMap="{Binding DataContext.security_map, RelativeSource={RelativeSource AncestorType=DataGrid}, Mode=OneWay}"
SelectedSecurity="{Binding value, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
ShowDialogSkirt="True"
/>
</DataTemplate>
</u:TemplateSelectorKeyValue>
<u:TemplateSelectorKeyValue Key="Name">
<DataTemplate>
<TextBox u:Behavior.FocusOnLoaded="True" Text="{Binding value}"/>
</DataTemplate>
</u:TemplateSelectorKeyValue>
<u:TemplateSelectorKeyValue Key="TickSize">
<DataTemplate>
<c:TickUpDownDouble Value="{Binding value, UpdateSourceTrigger=PropertyChanged}"/>
</DataTemplate>
</u:TemplateSelectorKeyValue>
<u:TemplateSelectorKeyValue Key="PriceMultiplier">
<DataTemplate>
<c:TickUpDownDouble Value="{Binding value}" DisplayConverter="{StaticResource DoubleTextConverter}"/>
</DataTemplate>
</u:TemplateSelectorKeyValue>
<u:TemplateSelectorKeyValue Key="Quantity">
<DataTemplate>
<c:TickUpDownDouble Value="{Binding value}" DisplayConverter="{StaticResource DoubleTextConverter}"/>
</DataTemplate>
</u:TemplateSelectorKeyValue>
<u:TemplateSelectorKeyValue Key="LegType">
<DataTemplate>
<spr:ContractLegTypeView Value="{Binding value}"/>
</DataTemplate>
</u:TemplateSelectorKeyValue>
</u:KeyedTemplateSelector>
</UserControl.Resources>
<!--Content-->
<Grid x:Name="content_root">
<Grid.RowDefinitions>
<RowDefinition Height="Auto"/>
<RowDefinition Height="*"/>
</Grid.RowDefinitions>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="Auto"/>
<ColumnDefinition Width="*"/>
</Grid.ColumnDefinitions>
<Image VerticalAlignment="Center" Margin="0,0,8,0">
<Image.Source>
<Binding Source="{x:Static MessageBoxImage.Exclamation}">
<Binding.Converter>
<cv:SystemIconConverter/>
</Binding.Converter>
</Binding>
</Image.Source>
</Image>
<Canvas x:Name="text_canvas" Grid.Column="1" HorizontalAlignment="Stretch"/>
<TextBlock Grid.Column="1" TextWrapping="Wrap" Width="{Binding ActualWidth, ElementName=text_canvas}">
<Run Text="{Binding num_successfully_parsed_rows, Mode=OneWay}"/>
<Run Text="/"/>
<Run Text="{Binding num_rows, Mode=OneWay}"/>
<Run Text=" synthetics were successfully converted."/>
<Run Text="Resolve conflicts below by selecting a value to assign each affected synthetic,"/>
<Run Text="or modify individual synthetics in the main window."/>
<LineBreak/>
<LineBreak/>
<Run Text="Click 'Continue' to proceed to the main window."/>
</TextBlock>
<DataGrid
x:Name="data_grid"
u:DataGridBehavior.SingleClickEdit="True"
Grid.Row="1"
Grid.ColumnSpan="2"
AutoGenerateColumns="False"
CanUserAddRows="False"
CanUserDeleteRows="False"
CanUserReorderColumns="False"
CanUserSortColumns="True"
HeadersVisibility="All"
ItemsSource="{Binding conflicts_view}"
Margin="0,8,0,0"
MinRowHeight="17"
RowHeaderWidth="22"
SelectionMode="Single"
>
<DataGrid.RowValidationErrorTemplate>
<ControlTemplate>
<Grid Background="Green">
<Border x:Name="exclamation" HorizontalAlignment="Center">
<Image Height="12" VerticalAlignment="Center" Source="{x:Static u:Icons.WarningExclamation}"/>
</Border>
<ContentControl HorizontalAlignment="Stretch" VerticalAlignment="Stretch" HorizontalContentAlignment="Stretch" VerticalContentAlignment="Stretch" ToolTip="{Binding (Validation.Errors), RelativeSource={RelativeSource AncestorType=DataGridRow}}">
<ContentControl.Template>
<ControlTemplate TargetType="ContentControl">
<Grid Background="Transparent">
<Grid.ToolTip>
<ToolTip Content="{Binding ToolTip, RelativeSource={RelativeSource TemplatedParent}}">
<ToolTip.ContentTemplate>
<DataTemplate>
<ItemsControl ItemsSource="{Binding}" DisplayMemberPath="ErrorContent"/>
</DataTemplate>
</ToolTip.ContentTemplate>
</ToolTip>
</Grid.ToolTip>
</Grid>
</ControlTemplate>
</ContentControl.Template>
</ContentControl>
</Grid>
</ControlTemplate>
</DataGrid.RowValidationErrorTemplate>
<DataGrid.CellStyle>
<Style TargetType="DataGridCell" BasedOn="{StaticResource DataGridCellBaseStyle}">
<Setter Property="VerticalContentAlignment" Value="Stretch"/>
</Style>
</DataGrid.CellStyle>
<DataGrid.RowStyle>
<Style TargetType="DataGridRow">
<Setter Property="ValidationErrorTemplate" Value="{Binding RowValidationErrorTemplate, RelativeSource={RelativeSource AncestorType=DataGrid}}"/>
<Setter Property="IsSelected" Value="{Binding is_selected, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"/>
<Style.Triggers>
<DataTrigger Binding="{Binding IsSelected, RelativeSource={RelativeSource Self}}" Value="True">
<Setter Property="Background" Value="{StaticResource SelectedRowBackground}"/>
</DataTrigger>
</Style.Triggers>
</Style>
</DataGrid.RowStyle>
<DataGrid.Columns>
<DataGridTextColumn Header="Component" Binding="{Binding component, Converter={StaticResource EnumDescriptionConverter}}" ElementStyle="{StaticResource VerticallyCenteredText}" IsReadOnly="True"/>
<DataGridTextColumn Header="Text" Binding="{Binding text}" ElementStyle="{StaticResource VerticallyCenteredText}" IsReadOnly="True"/>
<DataGridTextColumn Header="Affected Synthetics" Binding="{Binding num_affected_rows}" ElementStyle="{StaticResource VerticallyCenteredText}" IsReadOnly="True"/>
<DataGridTemplateColumn Header="Value" CellTemplateSelector="{StaticResource ValueCellTemplateSelector}" CellEditingTemplateSelector="{StaticResource ValueCellEditingTemplateSelector}"/>
</DataGrid.Columns>
</DataGrid>
</Grid>
</UserControl>
@@ -0,0 +1,20 @@
using System.Windows.Controls;
namespace bts.shell.spreader {
enum SyntheticContractComponent {
Name,
TickSize,
Security,
PriceMultiplier,
Quantity,
LegType
}
/// <summary>
/// Interaction logic for SyntheticImportConflictsView.xaml
/// </summary>
partial class SyntheticImportConflictsView : UserControl {
public SyntheticImportConflictsView() =>
InitializeComponent();
}
}
@@ -0,0 +1,45 @@
<Window
x:Class="bts.shell.spreader.SyntheticImportDialog"
x:ClassModifier="internal"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:u="clr-namespace:mbts.ui"
xmlns:c="clr-namespace:mbts.ui.controls"
xmlns:cv="clr-namespace:mbts.ui.converters"
xmlns:spr="clr-namespace:bts.shell.spreader"
u:WindowStyle.AllowResize="True"
u:WindowStyle.SizeToContent="WidthAndHeight"
u:WindowStyle.TitleContent="Import Synthetics"
Style="{StaticResource BTSDialogTitleTemplate}"
Content="{Binding}"
>
<Window.MaxHeight>
<Binding Path="SizeToContent" RelativeSource="{RelativeSource Self}">
<Binding.Converter>
<cv:WindowMaxHeightConverter SizeToContentThreshold="{u:DPIDouble 700}"/>
</Binding.Converter>
</Binding>
</Window.MaxHeight>
<u:WindowStyle.TitleContentTemplate>
<DataTemplate>
<StackPanel Orientation="Horizontal" HorizontalAlignment="Left">
<Image Height="12" Margin="5,2" Source="{x:Static u:Icons.Import}"/>
<TextBlock Margin="4,0,0,0" Text="{Binding}"/>
</StackPanel>
</DataTemplate>
</u:WindowStyle.TitleContentTemplate>
<Window.ContentTemplate>
<DataTemplate DataType="{x:Type spr:SyntheticImportVM}">
<AdornerDecorator>
<Grid>
<Grid.RowDefinitions>
<RowDefinition Height="*"/>
<RowDefinition Height="Auto"/>
</Grid.RowDefinitions>
<spr:SyntheticImportView/>
<c:DialogSkirtOKCancel Grid.Row="1" OKCommand="{Binding ok_cmd}" CancelCommand="{Binding cancel_cmd}"/>
</Grid>
</AdornerDecorator>
</DataTemplate>
</Window.ContentTemplate>
</Window>
@@ -0,0 +1,11 @@
using System.Windows;
namespace bts.shell.spreader {
/// <summary>
/// Interaction logic for SyntheticImportDialog.xaml
/// </summary>
partial class SyntheticImportDialog : Window {
public SyntheticImportDialog() =>
InitializeComponent();
}
}
@@ -0,0 +1,236 @@
using mbts;
using mbts.ui;
using mbts.ui.shell;
using mbts.ui.utility;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Windows.Data;
namespace bts.shell.spreader {
class SyntheticImportRowCollectionView : ListCollectionView {
ReadOnlyObservableCollection<object> _base_groups, _groups_wrapper;
ObservableAutoWrapper<object, object> _groups;
public SyntheticImportRowCollectionView(IList list)
: base(list) { }
public override bool CanGroup => true;
// Must return null if there are no GroupDescriptions (i.e., instead of an empty collection).
// If an empty collection is returned, the view assumes grouping is active and there are no items.
public override ReadOnlyObservableCollection<object> Groups {
get {
if ((GroupDescriptions?.Count ?? 0) == 0)
return null;
if (_groups_wrapper == null) {
_base_groups = base.Groups;
if (_base_groups == null)
return null;
_groups = new ObservableAutoWrapper<object, object>(_base_groups, obj => new SyntheticImportRowCollectionViewGroup((CollectionViewGroup)obj, this));
_groups_wrapper = new ReadOnlyObservableCollection<object>(_groups);
}
return _groups_wrapper;
}
}
public void set_all_expanded(bool is_expanded) {
foreach (var g in Groups.OfTypeSafe<SyntheticImportRowCollectionViewGroup>())
g.set_all_expanded(is_expanded);
}
}
class SyntheticImportRowCollectionViewGroup : CollectionViewGroup, INotifyDataErrorInfo, IRaiseNotifyPropertyChanged, IEquatable<SyntheticImportRowCollectionViewGroup> {
static readonly string _desc_delim = ", ";
readonly SyntheticImportRowCollectionView _root;
readonly CollectionViewGroup _from;
readonly Dictionary<object, InnerGroupSubscription> _inner_groups = new Dictionary<object, InnerGroupSubscription>();
readonly Dictionary<int, IDisposable> _rows = new Dictionary<int, IDisposable>();
string
_leg_type_desc,
_security_desc,
_quantity_desc,
_price_multiplier_desc;
IDisposable _dispose;
bool _is_expanded;
public SyntheticImportRowCollectionViewGroup(CollectionViewGroup from, SyntheticImportRowCollectionView root) : base(from.Name) {
_root = root;
_from = from;
((INotifyCollectionChanged)_from.Items).CollectionChanged += _from_items_CollectionChanged;
_from_items_CollectionChanged(_from.Items, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, _from.Items, 0));
}
public event Action ProtectedItemCountChanged;
public event EventHandler<DataErrorsChangedEventArgs> ErrorsChanged;
public override bool IsBottomLevel => _from.IsBottomLevel;
public bool is_expanded { get => _is_expanded; set => _set(ref _is_expanded, value); }
public int level => parent == null ? 1 : parent.level + 1;
public SyntheticImportRowCollectionViewGroup parent { get; private set; }
// leg type desc
public string leg_type_desc =>
_leg_type_desc ?? (_leg_type_desc = string.Join(_desc_delim, ProtectedItems.OfType<ContractLegVM>().Select(l => l.leg_type.display_name())));
// price multiplier desc
public string price_multiplier_desc =>
_price_multiplier_desc ?? (_price_multiplier_desc = string.Join(_desc_delim, ProtectedItems.OfType<ContractLegVM>().Select(l => l.price_multiplier)));
// quantity desc
public string quantity_desc =>
_quantity_desc ?? (_quantity_desc = string.Join(_desc_delim, ProtectedItems.OfType<ContractLegVM>().Select(l => l.quantity)));
// security desc
public string security_desc =>
_security_desc ?? (_security_desc = string.Join(_desc_delim, ProtectedItems.OfType<ContractLegVM>().Select(l => l.security?.ToString() ?? "?").ExceptNull()).if_null_or_empty("(No Legs)"));
new int ProtectedItemCount {
get => base.ProtectedItemCount;
set {
if (base.ProtectedItemCount != value) {
base.ProtectedItemCount = value;
ProtectedItemCountChanged?.Invoke();
}
}
}
public bool HasErrors => Items.OfType<ContractLegVM>().Any(l => l.HasErrors);
public IEnumerable GetErrors(string propertyName) =>
propertyName == nameof(Items) ?
Items.OfType<ContractLegVM>().SelectMany(l => l.AllErrors) :
Enumerable.Empty<string>();
public void set_all_expanded(bool is_expanded) {
this.is_expanded = is_expanded;
foreach (var g in Items.OfTypeSafe<SyntheticImportRowCollectionViewGroup>())
g.set_all_expanded(is_expanded);
}
public bool Equals(SyntheticImportRowCollectionViewGroup other) =>
other != null &&
level == other.level &&
Equals(Name, other.Name);
void IRaiseNotifyPropertyChanged.raise_notify_property_changed(string prop) =>
OnPropertyChanged(new PropertyChangedEventArgs(prop));
void _add_item(int index, object item) {
Log.assert(index >= 0, "Index is less than 0.");
if (item is CollectionViewGroup group) {
var inner_group = new SyntheticImportRowCollectionViewGroup(group, _root);
_inner_groups.Add(group.Name, new InnerGroupSubscription(this, inner_group));
ProtectedItems.Insert(index, inner_group);
} else {
var row = (ContractLegVM)item;
if (_rows.TryPopValue(row.id, out var sub))
sub.Dispose();
_rows[row.id] = _connect_row(row);
ProtectedItems.Insert(index, item);
}
}
void _remove_item(int index, object item) {
if (item is SyntheticImportRowCollectionViewGroup inner_group) {
if (!_inner_groups.TryPopValue(inner_group.Name, out var ig_sub))
throw new InvalidOperationException($"Inner groups cache does not have an entry for the specified name '{inner_group.Name}' (entire tree structure may be compromised).");
ig_sub.Dispose();
Disposable.dispose(ref inner_group._dispose);
}
ProtectedItems.RemoveAt(index);
}
void _from_items_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e) {
switch (e.Action) {
case NotifyCollectionChangedAction.Add:
for (int i = 0; i < e.NewItems.Count; i++)
_add_item(e.NewStartingIndex + i, e.NewItems[i]);
break;
case NotifyCollectionChangedAction.Remove:
for (int i = 0; i < e.OldItems.Count; i++)
_remove_item(e.OldStartingIndex, ProtectedItems[e.OldStartingIndex]);
break;
case NotifyCollectionChangedAction.Replace:
for (int i = 0; i < e.OldItems.Count; i++)
_remove_item(e.OldStartingIndex, ProtectedItems[e.OldStartingIndex]);
for (int i = 0; i < e.NewItems.Count; i++)
_add_item(e.NewStartingIndex + i, e.NewItems[i]);
break;
case NotifyCollectionChangedAction.Reset:
while (ProtectedItems.Count > 0)
_remove_item(0, ProtectedItems[0]);
for (int i = 0; i < _from.Items.Count; i++)
_add_item(i, _from.Items[i]);
break;
}
}
void _invalidate_props(params string[] props) {
for (int i = 0; i < props.Length; i++)
OnPropertyChanged(new PropertyChangedEventArgs(props[i]));
}
void _set<T>(ref T backing, T new_value, [CallerMemberName]string prop = "") =>
_set(ref backing, new_value, EqualityComparer<T>.Default, prop);
void _set<T>(ref T backing, T new_value, IEqualityComparer<T> comparer, [CallerMemberName]string prop = "") {
if (!comparer.Equals(backing, new_value)) {
backing = new_value;
OnPropertyChanged(new PropertyChangedEventArgs(prop));
}
}
IDisposable _connect_row(ContractLegVM row) {
row.result_changed += on_result_changed;
row.ErrorsChanged += on_errors_changed;
return Disposable.Create(() => {
row.result_changed -= on_result_changed;
row.ErrorsChanged -= on_errors_changed;
});
void on_result_changed() {
_security_desc = null;
_price_multiplier_desc = null;
_quantity_desc = null;
_leg_type_desc = null;
_invalidate_props(nameof(security_desc), nameof(price_multiplier_desc), nameof(quantity_desc), nameof(leg_type_desc));
}
void on_errors_changed(object sender, DataErrorsChangedEventArgs e) =>
ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(nameof(Items)));
}
class InnerGroupSubscription : IDisposable {
public readonly SyntheticImportRowCollectionViewGroup _inner_group;
readonly SyntheticImportRowCollectionViewGroup _parent;
int _last_count;
public InnerGroupSubscription(SyntheticImportRowCollectionViewGroup parent, SyntheticImportRowCollectionViewGroup inner_group) {
_parent = parent;
_inner_group = inner_group;
_inner_group.parent = parent;
// init item count
_on_item_count_changed();
// listen to item count changes
_inner_group.ProtectedItemCountChanged += _on_item_count_changed;
}
public void Dispose() {
_inner_group.ProtectedItemCountChanged -= _on_item_count_changed;
_inner_group.parent = null;
// make sure the state is valid (if a bad state goes by undetected here, nefarious/difficult-to-track bugs could arise)
if (_last_count != _inner_group.ProtectedItemCount) {
Log.Ui.warn("Cached inner count is not equal to the inner group's ItemCount (entire tree structure may be compromised).");
}
_parent.ProtectedItemCount -= _last_count;
}
void _on_item_count_changed() {
// add the delta
_parent.ProtectedItemCount += (_inner_group.ProtectedItemCount - _last_count);
// reset the local cache
_last_count = _inner_group.ProtectedItemCount;
}
}
}
}
@@ -0,0 +1,252 @@
using bts.api;
using bts.collections;
using bts.spark;
using mbts;
using mbts.collections;
using mbts.spark;
using mbts.ui;
using mbts.ui.shell;
using mbts.ui.utility;
using mbts.user.settings;
using mbts.utils;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Linq;
using System.Reactive.Linq;
using System.Windows.Data;
using System.Windows.Input;
using Disposable = mbts.Disposable;
namespace bts.shell.spreader {
class SyntheticImportVM : DisposableViewModelBase, IRequestViewClose {
IReadOnlyDictionary<uint, SecurityMD> _security_map = DictionaryHelper.empty<uint, SecurityMD>();
public SyntheticImportVM() {
var rows_view = new SyntheticImportRowCollectionView(flat_legs);
rows_view.GroupDescriptions.Add(new PropertyGroupDescription(nameof(ContractLegVM.owner)));
this.rows_view = rows_view;
ok_cmd = new DelegateCommand(() => import_request?.Invoke());
cancel_cmd = new DelegateCommand(() => RequestClose?.Invoke(this, new EventArgs()));
_dispose = ObservableAutoWrapper.connect_item_hooks(
rows,
r => {
flat_legs.AddRange(r.legs);
return Disposable.Create(() => flat_legs.removeRange(r.legs));
});
}
public event Action import_request;
public event EventHandler RequestClose;
public ObservableCollection<SyntheticImportRowVM> rows { get; } = new ObservableCollection<SyntheticImportRowVM>();
public ObservableCollection<ContractLegVM> flat_legs { get; } = new ObservableCollection<ContractLegVM>();
public IReadOnlyDictionary<uint, SecurityMD> security_map { get => _security_map; set => Set(ref _security_map, value); }
public ICollectionView rows_view { get; }
// commands
public ICommand ok_cmd { get; }
public ICommand cancel_cmd { get; }
}
class SyntheticImportRowVM : DisposableViewModelBase, IEquatable<SyntheticImportRowVM> {
readonly ReactiveThresholdMonitor<ContractLegVM> _leg_errors_mon = new ReactiveThresholdMonitor<ContractLegVM>(l => l.subscribe_has_errors(true));
readonly Func<string, bool> _get_name_exists;
SecurityImmutable? _security;
ExecutionStrategyImmutable? _strategy;
TickFactors _tick_factors;
string _name;
bool _is_selected;
public SyntheticImportRowVM(uint user_id, Func<string, bool> get_name_exists) {
this.user_id = user_id;
_get_name_exists = get_name_exists;
_validate();
add_leg_cmd = new DelegateCommand<SyntheticImportRowVM>(r => {
if (r != null) {
r.legs.Add(new ContractLegVM {
price_multiplier = 1,
quantity = 1,
owner = r
});
}
});
remove_leg_cmd = new DelegateCommand<ContractLegVM>(l => l?.owner?.legs?.Remove(l));
PropertyChanged += on_property_changed;
var disp = new DisposableCombo(
_leg_errors_mon.OnDispatcher().Subscribe(v => _validate()),
ObservableAutoWrapper.connect_item_hooks(legs,
l => {
l.result_changed += invalidate;
return new DisposableCombo(_leg_errors_mon.join(l), l) +
new Action(() => l.result_changed -= invalidate);
})) +
new Action(() => PropertyChanged -= on_property_changed);
void invalidate() {
_security = null;
_strategy = null;
_validate();
result_changed?.Invoke();
}
void on_property_changed(object sender, PropertyChangedEventArgs e) =>
invalidate();
}
public event Action result_changed;
public SecurityImmutable result =>
_security ?? (_security = new SecurityImmutable(to_security())).Value;
public ExecutionStrategyImmutable strategy =>
_strategy ?? (_strategy = new ExecutionStrategyImmutable(to_strategy())).Value;
public (SecurityImmutable security, ExecutionStrategyImmutable strategy) result_tuple =>
(result, strategy);
public ParsedSyntheticContract parsed_synth { get; set; }
public string name { get => _name; set => Set(ref _name, value); }
public uint user_id { get; }
public TickFactors tick_factors { get => _tick_factors; set => Set(ref _tick_factors, value); }
public ObservableCollection<ContractLegVM> legs { get; } = new ObservableCollection<ContractLegVM>();
public bool is_selected { get => _is_selected; set => Set(ref _is_selected, value); }
public ICommand add_leg_cmd { get; }
public ICommand remove_leg_cmd { get; }
public Security to_security() {
var sc = new SyntheticContract {
Name = name,
UserId = user_id
};
sc.Legs.AddRange(legs.Select(l => l.to_contract_leg()));
return new Security {
Synthetic = sc,
Symbol = sc.Legs.FirstOrDefault()?.Security?.Symbol ?? string.Empty,
Exchange = Venue.Bts,
ContractSpec = tick_factors.to_spec()
};
}
public ExecutionStrategy to_strategy() {
var strat = new ExecutionStrategy();
foreach (var l in legs) {
if (l.security.HasValue)
strat.LegParamsMap[l.security.Value.Id] = l.to_leg_params();
}
return strat;
}
void _validate() {
using (validation()) {
if (string.IsNullOrEmpty(name)) {
validation_assert(false, "Name is not specified.", nameof(name));
} else if (_get_name_exists(name)) {
validation_assert(false, "Name already exists.", nameof(name));
}
validation_assert(tick_factors != null && tick_factors.is_valid(), "Invalid tick", nameof(tick_factors));
validation_assert(legs.Count > 0 && !_leg_errors_mon.is_above_threshold, "Invalid legs.", nameof(legs));
}
}
public bool Equals(SyntheticImportRowVM other) =>
other != null &&
parsed_synth.unpersisted_id == other.parsed_synth.unpersisted_id;
public override bool Equals(object obj) =>
Equals(obj as SyntheticImportRowVM);
public override int GetHashCode() =>
parsed_synth.unpersisted_id;
}
class ContractLegVM : DisposableViewModelBase, IEquatable<ContractLegVM> {
ContractLegImmutable? _leg;
LegSpreaderParamsImmutable? _leg_params;
SecurityImmutable? _security;
double _price_multiplier, _quantity;
ContractLegType _leg_type;
bool _is_selected;
public ContractLegVM() {
PropertyChanged += on_property_changed;
_dispose = Disposable.Create(() => PropertyChanged -= on_property_changed);
_validate();
void on_property_changed(object sender, PropertyChangedEventArgs e) {
switch (e.PropertyName) {
case nameof(security):
case nameof(price_multiplier):
case nameof(quantity):
_leg = null;
break;
case nameof(leg_type):
_leg_params = null;
break;
default: return;
}
_validate();
result_changed?.Invoke();
}
}
public event Action result_changed;
public ParsedContractLeg parsed_leg { get; set; }
public SyntheticImportRowVM owner { get; set; }
public int owner_id => owner.parsed_synth.unpersisted_id;
public int id => parsed_leg.id;
public ContractLegImmutable leg =>
_leg ?? (_leg = new ContractLegImmutable(to_contract_leg())).Value;
public LegSpreaderParamsImmutable leg_params =>
_leg_params ?? (_leg_params = new LegSpreaderParamsImmutable(to_leg_params())).Value;
public (ContractLegImmutable leg, LegSpreaderParamsImmutable leg_params) result_tuple =>
(leg, leg_params);
public SecurityImmutable? security { get => _security; set => Set(ref _security, value); }
public double price_multiplier { get => _price_multiplier; set => Set(ref _price_multiplier, value); }
public double quantity { get => _quantity; set => Set(ref _quantity, value); }
public ContractLegType leg_type { get => _leg_type; set => Set(ref _leg_type, value); }
public bool is_selected { get => _is_selected; set => Set(ref _is_selected, value); }
public void load(ContractLegImmutable leg) {
security = leg.Security;
price_multiplier = leg.PriceMultiplier;
quantity = leg.Quantity;
}
public ContractLeg to_contract_leg() =>
new ContractLeg {
Security = security?.CloneToMutable(),
PriceMultiplier = price_multiplier,
Quantity = quantity
};
public LegSpreaderParams to_leg_params() {
var lps = SyntheticDataHelper.Defaults.LegSpreaderParams;
lps.EnableHedging = (leg_type & ContractLegType.Hedge) != 0;
lps.IsActiveQuoting = (leg_type & ContractLegType.Quote) != 0;
return lps;
}
void _validate() {
using (validation()) {
validation_assert(security.is_exchange_security(), "Invalid security", nameof(security));
validation_assert(price_multiplier.IsNonZero(), "Invalid price multiplier", nameof(price_multiplier));
validation_assert(quantity.IsNonZero(), "Invalid quantity", nameof(quantity));
}
}
public bool Equals(ContractLegVM other) =>
other != null && id == other.id;
public override bool Equals(object obj) =>
Equals(obj as ContractLegVM);
public override int GetHashCode() =>
id;
}
}
@@ -0,0 +1,270 @@
<UserControl
x:Class="bts.shell.spreader.SyntheticImportView"
x:ClassModifier="internal"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:u="clr-namespace:mbts.ui"
xmlns:c="clr-namespace:mbts.ui.controls"
xmlns:cv="clr-namespace:mbts.ui.converters"
xmlns:spr="clr-namespace:bts.shell.spreader"
xmlns:pnl="clr-namespace:bts.shell.pnl"
MinWidth="400"
Content="{Binding}"
>
<UserControl.Resources>
<cv:GridLengthConverter x:Key="GridLengthPixelConverter" UnitType="Pixel"/>
<Style x:Key="GroupDesc" TargetType="TextBlock">
<Setter Property="Margin" Value="{x:Static spr:SyntheticImportView.CellPadding}"/>
<Setter Property="ToolTip" Value="{Binding Text, RelativeSource={RelativeSource Self}}"/>
<Setter Property="VerticalAlignment" Value="Center"/>
<Setter Property="Foreground" Value="#80000000"/>
<Setter Property="FontStyle" Value="Italic"/>
</Style>
<DataTemplate DataType="{x:Type spr:ContractLegVM}">
<c:ContractPickerPopup
HorizontalAlignment="Stretch"
VerticalAlignment="Stretch"
CloseOnCancel="True"
CloseOnOK="True"
Header="{Binding security}"
IsEditMode="False"
IsLazy="True"
SecurityMap="{Binding DataContext.security_map, RelativeSource={RelativeSource AncestorType=DataGrid}, Mode=OneWay}"
SelectedSecurity="{Binding security, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
ShowDialogSkirt="True"
ToolTip="{Binding SelectedCriteria, RelativeSource={RelativeSource Self}, Converter={x:Static c:ContractPickerPopup.SecurityCriteriaTextConverter}, Mode=OneWay}"
/>
</DataTemplate>
<DataTemplate DataType="{x:Type spr:SyntheticImportVM}">
<c:DIYGrid
Grid.IsSharedSizeScope="True"
Rows="{Binding rows_view}"
RowHeight="{x:Static spr:SyntheticImportView.RowHeight}"
RowsHorizontalScrollBarVisibility="Collapsed"
SelectionHighlight="#30000000"
SelectionMode="Single"
SupportGroupItems="True"
>
<c:DIYGrid.Columns>
<c:DIYGridColumnCollection>
<spr:SyntheticImportColumn key="{x:Static spr:SyntheticImportColumns.Name}" Width="106"/>
<spr:SyntheticImportColumn key="{x:Static spr:SyntheticImportColumns.Ticks}" Width="128"/>
<spr:SyntheticImportColumn key="{x:Static spr:SyntheticImportColumns.Security}" Header="Securities" Width="120"/>
<spr:SyntheticImportColumn key="{x:Static spr:SyntheticImportColumns.Quantity}" Header="Quantities" Width="70"/>
<spr:SyntheticImportColumn key="{x:Static spr:SyntheticImportColumns.PriceMultiplier}" Header="Price Multipliers" Width="80"/>
<spr:SyntheticImportColumn key="{x:Static spr:SyntheticImportColumns.LegType}" Header="Leg Types" Width="83"/>
</c:DIYGridColumnCollection>
</c:DIYGrid.Columns>
<c:DIYGrid.GroupStyle>
<GroupStyle>
<GroupStyle.ContainerStyle>
<Style TargetType="GroupItem">
<Setter Property="HorizontalAlignment" Value="Left"/>
<EventSetter Event="MouseDown" Handler="_on_group_item_mouse_down"/>
<!--Note: Tag is bound to 'Items' so errors on the 'Items' prop will be included in Validation.Errors.-->
<Setter Property="Tag">
<Setter.Value>
<MultiBinding>
<MultiBinding.Converter>
<cv:MultiValueConverterPipe/>
</MultiBinding.Converter>
<Binding Path="Name.legs"/>
<Binding Path="Name.name"/>
</MultiBinding>
</Setter.Value>
</Setter>
<Setter Property="Template">
<Setter.Value>
<ControlTemplate TargetType="GroupItem">
<Grid
c:DIYGrid.SyncWithColumnGeometry="True"
u:StateManager.VisualState="{Binding IsChecked, ElementName=expander, Converter={x:Static pnl:PNLView.ExpandedVisualStateConverter}}"
Background="{TemplateBinding Background}"
>
<VisualStateManager.VisualStateGroups>
<VisualStateGroup Name="ExpansionStates">
<VisualState Name="Expanded"/>
<VisualState Name="Collapsed">
<Storyboard>
<ObjectAnimationUsingKeyFrames Storyboard.TargetName="presenter" Storyboard.TargetProperty="(UIElement.Visibility)">
<DiscreteObjectKeyFrame KeyTime="0" Value="{x:Static Visibility.Collapsed}"/>
</ObjectAnimationUsingKeyFrames>
</Storyboard>
</VisualState>
</VisualStateGroup>
</VisualStateManager.VisualStateGroups>
<Grid.RowDefinitions>
<RowDefinition Height="{Binding RowHeight, RelativeSource={RelativeSource AncestorType=c:DIYGrid}, Converter={StaticResource GridLengthPixelConverter}}"/>
<RowDefinition Height="*"/>
</Grid.RowDefinitions>
<Rectangle Grid.ColumnSpan="99" HorizontalAlignment="Stretch" VerticalAlignment="Bottom" Fill="Gray" UseLayoutRounding="True"/>
<!--Expander Toggle-->
<c:ExpanderToggleButton
x:Name="expander"
Grid.ColumnSpan="99"
Validation.ValidationAdornerSiteFor="{Binding RelativeSource={RelativeSource TemplatedParent}}"
ArrowPadding="14,2,0,0"
Background="{u:Brush Transparent}"
BorderThickness="0"
HorizontalAlignment="Stretch"
HorizontalContentAlignment="Left"
Height="{Binding RowHeight, RelativeSource={RelativeSource AncestorType=c:DIYGrid}}"
IsChecked="{Binding is_expanded}"
>
<u:StateManager.VisualState>
<Binding Path="TemplatedParent.(Validation.Errors).Count" RelativeSource="{RelativeSource Self}">
<Binding.Converter>
<cv:ValueConverterPipe>
<cv:IntGreaterThanConverter Value="0"/>
<cv:BooleanToObjectConverter ValueForFalse="NoErrors" ValueForTrue="Errors"/>
</cv:ValueConverterPipe>
</Binding.Converter>
</Binding>
</u:StateManager.VisualState>
<u:StateManager.Groups>
<u:StateGroupsManager AttachToMembers="True">
<u:StateDefinitionCollection>
<u:MouseStateDefinition MouseSource="{Binding Group.Target, RelativeSource={RelativeSource Self}}"/>
</u:StateDefinitionCollection>
</u:StateGroupsManager>
</u:StateManager.Groups>
<VisualStateManager.VisualStateGroups>
<VisualStateGroup Name="MouseStates">
<VisualState Name="Normal"/>
<VisualState Name="MouseOver">
<Storyboard>
<ColorAnimation Storyboard.TargetName="expander" Storyboard.TargetProperty="Background.Color" BeginTime="0" Duration="0" To="#10000000"/>
</Storyboard>
</VisualState>
<VisualState Name="Pressed">
<Storyboard>
<ColorAnimation Storyboard.TargetName="expander" Storyboard.TargetProperty="Background.Color" BeginTime="0" Duration="0" To="#10000000"/>
</Storyboard>
</VisualState>
</VisualStateGroup>
</VisualStateManager.VisualStateGroups>
<Validation.ErrorTemplate>
<ControlTemplate TargetType="Control">
<Grid>
<AdornedElementPlaceholder x:Name="adorned_element_pl"/>
<Border x:Name="exclamation" HorizontalAlignment="Left">
<Image Height="12" Margin="6,0,0,0" VerticalAlignment="Center" Source="{x:Static u:Icons.WarningExclamation}"/>
</Border>
<ContentControl u:Behavior.MirrorLayoutFor="{Binding ElementName=exclamation}" ToolTip="{Binding AdornedElement.(Validation.ValidationAdornerSiteFor).(Validation.Errors), ElementName=adorned_element_pl}">
<ContentControl.Template>
<ControlTemplate TargetType="ContentControl">
<Grid Background="Transparent">
<Grid.ToolTip>
<ToolTip Content="{Binding ToolTip, RelativeSource={RelativeSource TemplatedParent}}">
<ToolTip.ContentTemplate>
<DataTemplate>
<ItemsControl ItemsSource="{Binding}" DisplayMemberPath="ErrorContent"/>
</DataTemplate>
</ToolTip.ContentTemplate>
</ToolTip>
</Grid.ToolTip>
</Grid>
</ControlTemplate>
</ContentControl.Template>
</ContentControl>
</Grid>
</ControlTemplate>
</Validation.ErrorTemplate>
<Grid c:DIYGrid.SyncWithColumnGeometry="True" Margin="-22,0,0,0">
<c:EditableTextBlock
x:Name="PART_Name_EditableTextBlock"
Grid.Column="0"
Margin="22,0,0,0"
EndEditOnLostKeyboardFocus="True"
Foreground="{u:Brush Black}"
Text="{Binding Name.name}"
ToolTip="Click to Edit Name"
UseLayoutRounding="True"
VerticalAlignment="Center"
>
<c:EditableTextBlock.CommandBindings>
<CommandBinding Command="{x:Static c:EditableTextBlock.BeginEditCommand}" Executed="{x:Static c:EditableTextBlock.BeginEditExecuted}"/>
<CommandBinding Command="{x:Static c:EditableTextBlock.EndEditCommand}" Executed="{x:Static c:EditableTextBlock.EndEditExecuted}"/>
<CommandBinding Command="{x:Static c:EditableTextBlock.CancelEditCommand}" Executed="{x:Static c:EditableTextBlock.CancelEditExecuted}"/>
</c:EditableTextBlock.CommandBindings>
<c:EditableTextBlock.InputBindings>
<MouseBinding MouseAction="LeftClick" Command="{x:Static c:EditableTextBlock.BeginEditCommand}"/>
<KeyBinding Key="Return" Command="{x:Static c:EditableTextBlock.EndEditCommand}"/>
<KeyBinding Key="Esc" Command="{x:Static c:EditableTextBlock.CancelEditCommand}"/>
</c:EditableTextBlock.InputBindings>
</c:EditableTextBlock>
<c:TickFactorsPicker
c:DIYGrid.ColumnKey="{x:Static spr:SyntheticImportColumns.Ticks}"
Margin="{x:Static spr:SyntheticImportView.CellPadding}"
SelectedTickFactors="{Binding Name.tick_factors}"
UseLayoutRounding="True"
/>
<TextBlock c:DIYGrid.ColumnKey="{x:Static spr:SyntheticImportColumns.Security}" Text="{Binding security_desc}" Style="{StaticResource GroupDesc}"/>
<TextBlock c:DIYGrid.ColumnKey="{x:Static spr:SyntheticImportColumns.Quantity}" Text="{Binding quantity_desc}" Style="{StaticResource GroupDesc}"/>
<TextBlock c:DIYGrid.ColumnKey="{x:Static spr:SyntheticImportColumns.PriceMultiplier}" Text="{Binding price_multiplier_desc}" Style="{StaticResource GroupDesc}"/>
<TextBlock c:DIYGrid.ColumnKey="{x:Static spr:SyntheticImportColumns.LegType}" Text="{Binding leg_type_desc}" Style="{StaticResource GroupDesc}">
<TextBlock.ToolTip>
<TextBlock>
<Run Text="{Binding leg_type_desc, Mode=OneWay}"/>
<LineBreak/>
<Run Text="Q = Quote"/>
<LineBreak/>
<Run Text="H = Hedge"/>
<LineBreak/>
<Run Text="N = None"/>
</TextBlock>
</TextBlock.ToolTip>
</TextBlock>
</Grid>
</c:ExpanderToggleButton>
<ItemsPresenter x:Name="presenter" Grid.Row="1" Grid.ColumnSpan="99"/>
</Grid>
</ControlTemplate>
</Setter.Value>
</Setter>
</Style>
</GroupStyle.ContainerStyle>
</GroupStyle>
</c:DIYGrid.GroupStyle>
<c:DIYGrid.RowTemplate>
<DataTemplate DataType="{x:Type spr:ContractLegVM}">
<Grid c:DIYGrid.SyncWithColumnGeometry="True">
<c:ContractPickerPopup
c:DIYGrid.ColumnKey="{x:Static spr:SyntheticImportColumns.Security}"
Background="Transparent"
BorderThickness="0"
HorizontalAlignment="Stretch"
VerticalAlignment="Stretch"
Margin="{x:Static spr:SyntheticImportView.CellPadding}"
CloseOnCancel="True"
CloseOnOK="True"
Header="{Binding security, Converter={x:Static cv:ValueConverters.SecuritySelectorText}}"
IsEditMode="False"
IsLazy="True"
SecurityMap="{Binding DataContext.security_map, RelativeSource={RelativeSource AncestorType=c:DIYGrid}, Mode=OneWay}"
SelectedSecurity="{Binding security, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
ShowDialogSkirt="True"
ToolTip="{Binding SelectedSecurity, RelativeSource={RelativeSource Self}}"
>
</c:ContractPickerPopup>
<c:TickUpDownDouble
c:DIYGrid.ColumnKey="{x:Static spr:SyntheticImportColumns.Quantity}"
Margin="{x:Static spr:SyntheticImportView.CellPadding}"
Value="{Binding quantity}"
/>
<c:TickUpDownDouble
c:DIYGrid.ColumnKey="{x:Static spr:SyntheticImportColumns.PriceMultiplier}"
Margin="{x:Static spr:SyntheticImportView.CellPadding}"
Value="{Binding price_multiplier}"
/>
<spr:ContractLegTypeView
c:DIYGrid.ColumnKey="{x:Static spr:SyntheticImportColumns.LegType}"
Value="{Binding leg_type}"
/>
</Grid>
</DataTemplate>
</c:DIYGrid.RowTemplate>
</c:DIYGrid>
</DataTemplate>
</UserControl.Resources>
</UserControl>
@@ -0,0 +1,50 @@
using mbts.ui.controls;
using mbts.ui.dpi;
using mbts.ui.utility;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
namespace bts.shell.spreader {
enum SyntheticImportColumns {
Name = 1,
Security,
Ticks,
PriceMultiplier,
Quantity,
LegType
}
/// <summary>
/// Interaction logic for SyntheticImportView.xaml
/// </summary>
partial class SyntheticImportView : UserControl {
public static double RowHeight =>
27.0.RoundLayoutValue();
public static Thickness CellPadding =>
new Thickness(6, 3, 6, 3).RoundToLayout();
public SyntheticImportView() =>
InitializeComponent();
void _on_group_item_mouse_down(object sender, MouseButtonEventArgs e) {
if (!e.Handled && e.ClickCount == 2 && sender is FrameworkElement el && el.DataContext is SyntheticImportRowCollectionViewGroup group) {
group.is_expanded = !group.is_expanded;
e.Handled = true;
}
}
}
class SyntheticImportColumn : DIYGrid.ColumnBase<SyntheticImportColumns> {
public SyntheticImportColumn() =>
is_visible = true;
protected override void on_key_initialized(SyntheticImportColumns key) {
if (Header == null)
Header = EnumHelper.get_display_name(key);
if (id == null)
id = key.ToString();
}
}
}
@@ -0,0 +1,194 @@
using bts;
using bts.api;
using bts.collections;
using bts.shell.spreader;
using mbts.ui;
using mbts.ui.utility;
using mbts.utils;
using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.IO;
using System.Linq;
using System.Reactive.Linq;
using System.Threading.Tasks;
using System.Windows;
namespace mbts.spark {
static class SyntheticImporter {
const string _import_title = "Import Synthetics";
static readonly TimeSpan _import_op_sec_map_timeout = TimeSpan.FromSeconds(30);
public static IDisposable import_from_file(string path, IBus bus, OrdersModel orders_model) {
bool is_disposed = false;
IDisposable dispose_op = null;
dispose_op = Disposable.Create(() => is_disposed = true);
impl();
return Disposable.Create(() => Disposable.dispose(ref dispose_op));
async void impl() {
IReadOnlyDictionary<uint, SecurityMD> sec_md_map = null;
while (true) {
await Task.WhenAny(init_sec_md_map(), Task.Delay(_import_op_sec_map_timeout));
if (is_disposed)
return;
if (sec_md_map != null)
break;
if (!retry_on_error($"Synthetic import op timed out waiting for security map after {_import_op_sec_map_timeout.TotalSeconds:0.00} seconds."))
return;
}
// The following conditions should break the while loop:
// 1) the import succeeds
// 2) the import fails, and the user does not click 'Yes' in the 'try again...' confirmation dialog
while (true) {
string error_msg = null;
try {
var raw_lines = File.ReadAllLines(path);
var used_names = new HashSet<string>(sec_md_map.Values.Where(smd => smd.security.ContractCase == Security.ContractOneofCase.Synthetic)
.Select(smd => smd.security.Synthetic.Name));
var parsed_synths = SyntheticSecurityParser.parse_rows(raw_lines, MappedDictionary.create(sec_md_map, smd => smd.security), used_names).ToList();
var main_vm = new SyntheticImportVM() {
security_map = sec_md_map
};
// add rows/conflicts
main_vm.rows.AddRange(parsed_synths.Select(ps => {
var sec = ps.result;
var r = new SyntheticImportRowVM(orders_model.admin_model.user.id, used_names.Contains) {
tick_factors = TickUtils.get_regional_ticks(sec.ContractSpec).low_tick,
name = sec.Synthetic.Name,
parsed_synth = ps
};
r.legs.AddRange(ps.legs.Zip(sec.Synthetic.Legs).Select(tup => {
var (pl, l) = tup;
var leg_vm = new ContractLegVM {
price_multiplier = l.PriceMultiplier,
quantity = l.Quantity,
parsed_leg = pl,
owner = r,
leg_type =
(pl.result_tuple.leg_params.EnableHedging ? ContractLegType.Hedge : ContractLegType.None) |
(pl.result_tuple.leg_params.IsActiveQuoting ? ContractLegType.Quote : ContractLegType.None)
};
if (l.Security != null)
leg_vm.security = new SecurityImmutable(l.Security);
return leg_vm;
}));
return r;
}));
var main_win = new SyntheticImportDialog { DataContext = main_vm };
ui.WindowStyle.SetSizeToContent(main_win, SizeToContent.WidthAndHeight);
main_vm.import_request += on_main_import_request;
main_win.move_to_mouse(-200, -75);
dispose_op = WindowUtilities.connect_vm(main_win, main_vm, main_vm);
main_win.Show();
// conflicts
var conflicts = SyntheticSecurityParser.get_conflicts(main_vm.rows);
if (conflicts.Values.Any(c => c.Count > 0)) {
var conflicts_vm = new SyntheticImportConflictsVM(parsed_synths.Count) {
security_map = sec_md_map
};
foreach (var kv in conflicts) {
var assign_del = SyntheticSecurityParser.assign_component(kv.Key);
foreach (var text_groups in kv.Value) {
var eval = get_error_value(kv.Key);
var row = new SyntheticImportConflictRowVM(kv.Key, text_groups.Key, text_groups.Value, eval, eval);
conflicts_vm.conflicts.Add(row);
conflicts_vm.committed += () => {
foreach (var (synth, leg_vm) in text_groups.Value) {
var leg_tup = leg_vm?.parsed_leg?.result_tuple;
assign_del(synth.parsed_synth.result, leg_tup?.leg, leg_tup?.leg_params, row.value);
}
row.on_conflicts_resolved();
};
}
}
var conflicts_win = new SyntheticImportConflictsDialog {
DataContext = conflicts_vm,
Owner = main_win,
Title = $"{_import_title} Conflicts",
WindowStartupLocation = WindowStartupLocation.CenterOwner
};
dispose_op = new DisposableCombo(WindowUtilities.connect_vm(conflicts_win, conflicts_vm, conflicts_vm)) + dispose_op;
conflicts_win.ShowDialog();
}
object get_error_value(SyntheticContractComponent component) {
switch (component) {
case SyntheticContractComponent.PriceMultiplier:
case SyntheticContractComponent.Quantity: return double.NaN;
default: return null;
}
}
void on_main_import_request() {
if (!is_disposed)
import_synths(parsed_synths, main_vm.rows);
Disposable.dispose(ref dispose_op);
}
}
catch (Exception ex) {
error_msg = $"Error parsing synthetics from file '{path}': {ex}.";
}
if (error_msg == null) {
// Exit loop: the import succeeded.
break;
}
if (!retry_on_error(error_msg)) {
// Exit loop: the import failed, and the user did not click 'Yes' in the 'try again...' confirmation dialog.
break;
}
// Continue loop: the import failed, and the user wants to try again.
error_msg = null;
}
async void import_synths(IReadOnlyList<ParsedSyntheticContract> parsed_synths, IEnumerable<SyntheticImportRowVM> rows) {
(uint? key, string error_msg)[] new_ids = null;
string error_msg = null;
try {
new_ids = await orders_model.spreader.create_synthetics(
rows.Where(r => !r.HasErrors)
.Select(r => r.result_tuple));
}
catch (Exception ex) {
Log.Ui.error($"Failed to save all synthetics during import op (one or more may have been successfully saved): {ex}.");
error_msg = $"Import was unsuccessful: {ex}.";
}
if (new_ids == null)
error_msg = "An unknown error occurred (check the synthetic management window to see if any synthetics were successfully added).";
if (error_msg != null) {
BTSMessageBox.Show(error_msg, "Import Synthetics", BTSMessageBoxButtons.OK);
} else {
Log.assert(new_ids != null);
var failed = new_ids
.Where(r => !r.error_msg.is_null_or_empty())
.ToList();
int num_succeeded = new_ids.Length - failed.Count;
if (num_succeeded < parsed_synths.Count) {
if (!BTSMessageBox.Confirm(
$"{num_succeeded}/{parsed_synths.Count} synthetics were successfully imported.\n" +
"Would you like to keep the imports that were successful?",
_import_title)) {
bus.post(SparkTags.SyntheticDeleteTag,
ImmutableHashSet.CreateRange(new_ids.Where(r => r.key.HasValue).Select(r => r.key.Value)));
}
} else {
BTSMessageBox.Show(
$"All {num_succeeded} synthetics were successfully imported.",
_import_title,
BTSMessageBoxButtons.OK,
MessageBoxImage.Information);
}
}
}
async Task init_sec_md_map() =>
sec_md_map = await bus.subscribe(SparkTags.SecuritiesTag).OnDispatcher().FirstOrDefaultAsync();
bool retry_on_error(string error_msg) {
Log.Ui.warn(error_msg);
return BTSMessageBox.Confirm(error_msg + "\nTry again?", _import_title, MessageBoxImage.Exclamation);
}
}
}
}
}
@@ -0,0 +1,307 @@
using bts.api;
using bts.spark;
using bts.utils;
using mbts;
using mbts.ui.utility;
using mbts.utils;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Reactive.Linq;
namespace bts.shell.spreader {
[Flags]
enum ContractLegType {
None = 0,
Quote = 1,
Hedge = 2
}
class ParsedSyntheticContract : IDisposable {
[ThreadStatic]
static int _id_counter;
public readonly int unpersisted_id = unchecked(_id_counter++);
public readonly Security result = new Security {
Synthetic = new SyntheticContract(),
ContractSpec = new ContractSpecification(),
Exchange = Venue.Bts
};
readonly ReactiveThresholdMonitor<ParsedContractLeg> _legs_valid_mon =
new ReactiveThresholdMonitor<ParsedContractLeg>(l => l.subscribe_is_valid());
IDisposable _dispose;
public ParsedSyntheticContract() {
_dispose = Disposable.Create(
ObservableAutoWrapper.connect_item_hooks(legs, _legs_valid_mon.join),
_legs_valid_mon.Subscribe(_ => _is_dirty = true));
}
bool
_is_dirty,
_is_valid;
(string text, bool success)
_name,
_tick_size;
public (string text, bool success) name { get => _name; set => _set(ref _name, value); }
public (string text, bool success) tick_size { get => _tick_size; set => _set(ref _tick_size, value); }
public ObservableCollection<ParsedContractLeg> legs { get; } = new ObservableCollection<ParsedContractLeg>();
public bool is_valid {
get {
if (_is_dirty) {
_is_valid = tick_size.success && name.success && !_legs_valid_mon.is_above_threshold;
_is_dirty = false;
}
return _is_valid;
}
}
public ParsedContractLeg current_leg =>
legs.LastOrDefault() ?? add_new_leg();
public ParsedContractLeg add_new_leg() {
var leg = new ParsedContractLeg();
legs.Add(leg);
result.Synthetic.Legs.Add(leg.result);
return leg;
}
public void Dispose() =>
Disposable.dispose(ref _dispose);
public bool Equals(ParsedSyntheticContract other) => other != null && unpersisted_id == other.unpersisted_id;
public override bool Equals(object obj) => Equals(obj as ParsedSyntheticContract);
public override int GetHashCode() => unpersisted_id.GetHashCode();
void _set<T>(ref T backing, T value) {
backing = value;
_is_dirty = true;
}
}
class ParsedContractLeg {
[ThreadStatic]
static int _id_counter;
public readonly ContractLeg result = new ContractLeg { };
public readonly LegSpreaderParams leg_params = new LegSpreaderParams();
bool
_is_dirty,
_is_valid;
(string text, bool success)
_security,
_quantity,
_price_multiplier,
_leg_type;
public event Action invalidated;
public int id { get; } = unchecked(_id_counter++);
public (string text, bool success) security { get => _security; set => _set(ref _security, value); }
public (string text, bool success) quantity { get => _quantity; set => _set(ref _quantity, value); }
public (string text, bool success) price_multiplier { get => _price_multiplier; set => _set(ref _price_multiplier, value); }
public (string text, bool success) leg_type { get => _leg_type; set => _set(ref _leg_type, value); }
public (ContractLeg leg, LegSpreaderParams leg_params) result_tuple => (result, leg_params);
public bool is_valid {
get {
if (_is_dirty) {
if (_is_valid != (security.success && quantity.success && price_multiplier.success && leg_type.success)) {
_is_valid = !_is_valid;
invalidated?.Invoke();
}
_is_dirty = false;
}
return _is_valid;
}
}
public IObservable<bool> subscribe_is_valid() =>
Observable.Create<bool>(o => {
o.OnNext(is_valid);
invalidated += on_invalidated;
return Disposable.Create(() => invalidated -= on_invalidated);
void on_invalidated() =>
o.OnNext(is_valid);
});
void _set<T>(ref T backing, T value) {
backing = value;
_is_dirty = true;
}
}
static class SyntheticSecurityParser {
public const string file_extension = "csv";
public static string display_name(this ContractLegType leg_type) {
if (leg_type == ContractLegType.None)
return "N";
var flags = EnumHelper.split_flags(leg_type);
return string.Join("", flags.Select(f => f.ToString())
.Where(str => str.Length > 0)
.Select(str => str.Substring(0, 1)));
}
public static Action<Security, ContractLeg, LegSpreaderParams, object> assign_component(SyntheticContractComponent component) {
switch (component) {
case SyntheticContractComponent.Name: return (sec, leg, leg_params, val) => sec.Synthetic.Name = val?.ToString() ?? string.Empty;
case SyntheticContractComponent.TickSize: return (sec, leg, leg_params, val) => sec.ContractSpec.LowTick = sec.ContractSpec.HighTick = ConvertUtils.try_convert<double?>(val) ?? 0.0;
case SyntheticContractComponent.PriceMultiplier: return (sec, leg, leg_params, val) => leg.PriceMultiplier = ConvertUtils.try_convert<double?>(val) ?? double.NaN;
case SyntheticContractComponent.Quantity: return (sec, leg, leg_params, val) => leg.Quantity = ConvertUtils.try_convert<double?>(val) ?? double.NaN;
case SyntheticContractComponent.Security: return (sec, leg, leg_params, val) => leg.Security = val as Security ?? (val is SecurityImmutable si ? si.CloneToMutable() : null);
case SyntheticContractComponent.LegType: return (sec, leg, leg_params, val) => assign_leg_type(leg_params, ConvertUtils.try_convert(val, out ContractLegType lt) ? lt : ContractLegType.None);
default: throw new NotImplementedException();
}
}
/// Note: the returned dictionary will have entries for each <see cref="SyntheticContractComponent"/>, regardless of whether or not that component has any conflicts.
public static Dictionary<SyntheticContractComponent, Dictionary<string, List<(ParsedSyntheticContract synth, ParsedContractLeg leg)>>> get_conflicts(IEnumerable<ParsedSyntheticContract> parsed_fills) {
var missing_components = EnumHelper.get_values<SyntheticContractComponent>().ToDictionary(c => c, c => new Dictionary<string, List<(ParsedSyntheticContract synth, ParsedContractLeg leg)>>());
var mk_list = new Func<string, List<(ParsedSyntheticContract synth, ParsedContractLeg leg)>>(_ => new List<(ParsedSyntheticContract, ParsedContractLeg)>());
foreach (var psc in parsed_fills) {
if (!psc.name.success) {
add_missing(SyntheticContractComponent.Name, psc.name.text, psc);
}
if (!psc.tick_size.success) {
add_missing(SyntheticContractComponent.TickSize, psc.tick_size.text, psc);
}
foreach (var leg in psc.legs) {
if (!leg.price_multiplier.success)
add_missing(SyntheticContractComponent.PriceMultiplier, leg.price_multiplier.text, psc, leg);
if (!leg.quantity.success)
add_missing(SyntheticContractComponent.Quantity, leg.quantity.text, psc, leg);
if (!leg.security.success)
add_missing(SyntheticContractComponent.Security, leg.security.text, psc, leg);
if (!leg.leg_type.success)
add_missing(SyntheticContractComponent.LegType, leg.leg_type.text, psc, leg);
}
}
return missing_components;
void add_missing(SyntheticContractComponent component, string text, ParsedSyntheticContract result, ParsedContractLeg leg = null) =>
missing_components[component].GetOrAdd(text ?? string.Empty, mk_list).Add((result, leg));
}
public static Dictionary<SyntheticContractComponent, Dictionary<string, List<(SyntheticImportRowVM row, ContractLegVM leg)>>> get_conflicts(IEnumerable<SyntheticImportRowVM> import_rows) {
var missing_components = EnumHelper.get_values<SyntheticContractComponent>().ToDictionary(c => c, c => new Dictionary<string, List<(SyntheticImportRowVM row, ContractLegVM leg)>>());
var mk_list = new Func<string, List<(SyntheticImportRowVM row, ContractLegVM leg)>>(_ => new List<(SyntheticImportRowVM, ContractLegVM)>());
foreach (var ir in import_rows) {
var psc = ir.parsed_synth;
if (!psc.name.success) {
add_missing(SyntheticContractComponent.Name, psc.name.text, ir);
}
if (!psc.tick_size.success) {
add_missing(SyntheticContractComponent.TickSize, psc.tick_size.text, ir);
}
foreach (var leg in ir.legs) {
if (!leg.parsed_leg.price_multiplier.success)
add_missing(SyntheticContractComponent.PriceMultiplier, leg.parsed_leg.price_multiplier.text, ir, leg);
if (!leg.parsed_leg.quantity.success)
add_missing(SyntheticContractComponent.Quantity, leg.parsed_leg.quantity.text, ir, leg);
if (!leg.parsed_leg.security.success)
add_missing(SyntheticContractComponent.Security, leg.parsed_leg.security.text, ir, leg);
if (!leg.parsed_leg.leg_type.success)
add_missing(SyntheticContractComponent.LegType, leg.parsed_leg.leg_type.text, ir, leg);
}
}
return missing_components;
void add_missing(SyntheticContractComponent component, string text, SyntheticImportRowVM row, ContractLegVM leg = null) =>
missing_components[component].GetOrAdd(text ?? string.Empty, mk_list).Add((row, leg));
}
// This implementation prioritizes simplicity over speed.
// The security desc lookup could be better optimized, but the speed at which fills are imported is probably not a paramount concern.
public static IEnumerable<ParsedSyntheticContract> parse_rows(IEnumerable<string> rows, IReadOnlyDictionary<uint, SecurityImmutable> security_map, ISet<string> used_names) {
var sec_lookup = security_map.ToLookup(kv => kv.Value.ToString());
var name_col = Cells.name(used_names.Contains);
var sec_col = Cells.contract_security(lookup_security);
return RowParser.parse_rows(rows, columns(), Cells.delimiter);
Security lookup_security(string sec_text) =>
sec_lookup.Contains(sec_text) ? sec_lookup[sec_text].First().Value.CloneToMutable() : null;
IEnumerable<RowParser.AssignColumnValue<ParsedSyntheticContract>> columns() {
yield return name_col;
yield return Cells.tick_size;
// if an imported synth has > 255 legs, assume it is an error.
const int max_legs = 255;
int leg_count = 0;
do {
yield return sec_col;
yield return Cells.contract_quantity;
yield return Cells.contract_price_multiplier;
yield return Cells.leg_type;
} while (leg_count++ < max_legs);
}
}
public static Func<string, TKey> reverse_lookup<TKey>(IReadOnlyDictionary<TKey, string> map) {
var lookup = map.ToLookup(kv => kv.Value, kv => kv.Key);
return cell_text => lookup.Contains(cell_text) ? lookup[cell_text].First() : default;
}
public static void assign_leg_type(LegSpreaderParams leg_params, ContractLegType leg_type) {
leg_params.IsActiveQuoting = (leg_type & ContractLegType.Quote) != 0;
leg_params.EnableHedging = (leg_type & ContractLegType.Hedge) != 0;
}
static class Cells {
public const char delimiter = ',';
public static RowParser.AssignColumnValue<ParsedSyntheticContract> name(Func<string, bool> name_exists) =>
(ref ParsedSyntheticContract psc, string cell_text) => {
psc.name = (cell_text, !name_exists(cell_text));
psc.result.Synthetic.Name = cell_text;
};
public static void tick_size(ref ParsedSyntheticContract psc, string cell_text) {
psc.tick_size = (cell_text, double.TryParse(cell_text.Trim(), out var val));
if (psc.tick_size.success) {
psc.tick_size = (cell_text, val.IsNonZero());
psc.result.ContractSpec.LowTick = psc.result.ContractSpec.HighTick = val;
}
}
public static RowParser.AssignColumnValue<ParsedSyntheticContract> contract_security(Func<string, Security> reverse_security_lookup) =>
(ref ParsedSyntheticContract psc, string cell_text) => {
var leg = psc.add_new_leg();
leg.result.Security = reverse_security_lookup(cell_text.Trim());
leg.security = (cell_text, leg.result.Security != null);
};
public static void contract_quantity(ref ParsedSyntheticContract psc, string cell_text) {
psc.current_leg.quantity = (cell_text, double.TryParse(cell_text.Trim(), out var val) && val.IsNonZero());
psc.current_leg.result.Quantity = val;
}
public static void contract_price_multiplier(ref ParsedSyntheticContract psc, string cell_text) {
psc.current_leg.price_multiplier = (cell_text, double.TryParse(cell_text.Trim(), out var val) && val.IsNonZero());
psc.current_leg.result.PriceMultiplier = val;
}
public static void leg_type(ref ParsedSyntheticContract psc, string cell_text) {
psc.current_leg.leg_type = (cell_text, _parse_leg_type(cell_text.Trim(), out var leg_type));
assign_leg_type(psc.current_leg.leg_params, leg_type);
}
static bool _parse_leg_type(string cell_text, out ContractLegType result) {
result = ContractLegType.None;
if (cell_text.IsNullOrEmpty())
return false;
switch (char.ToUpper(cell_text[0])) {
case 'Q': result = ContractLegType.Quote; break;
case 'H': result = ContractLegType.Hedge; break;
case 'N': break;
default: return false;
}
return true;
}
}
}
}
@@ -4,6 +4,8 @@ using bts.api.core;
using bts.api.synthetic;
using bts.collections;
using bts.spark;
using bts.utils;
using mbts.utils;
using System;
using System.Collections.Generic;
using System.ComponentModel.Composition;
@@ -82,6 +84,61 @@ namespace mbts.spark {
(mdc, success) => success ? mdc.Data[0].Strategy : (ExecutionStrategyImmutable?)null,
"lookup strategy");
public Task<(uint? key, string error_msg)[]> create_synthetics(IEnumerable<(SecurityImmutable security, ExecutionStrategyImmutable strategy)> synthetics) {
var tasks = synthetics.Select(tup => {
var (sec, strat) = tup;
if (sec.ContractCase != Security.ContractOneofCase.Synthetic)
return Task.FromException<(Result<CreateResult>, Result<UpdateResult>?)>(ExceptionBuilder.Argument.unexpected_case(sec.ContractCase, nameof(sec)));
if (sec.Synthetic.UserId != _user_id) {
var msec = sec.CloneToMutable();
msec.Synthetic.UserId = _user_id;
sec = new SecurityImmutable(msec);
}
return impl();
async Task<(Result<CreateResult> sec, Result<UpdateResult>? strat)> impl() {
var result = await _service.create_synthetic_async(sec);
Result<UpdateResult>? strategy;
if (result.success && result.value.Error == CreateResult.Types.Error.Ok) {
strategy = await _service.update_security_metadata_async(new Metadata {
SecurityKey = result.value.Key,
Strategy = tup.strategy.CloneToMutable()
});
} else {
strategy = null;
}
return (result, strategy);
}
});
return _error.safe_execute_batch(tasks,
tup => {
var (sec, strat) = tup;
// security
string sec_error_msg = null;
uint? key = null;
if (!sec.success) {
sec_error_msg = sec.error_message;
} else if (sec.value.Error != CreateResult.Types.Error.Ok) {
sec_error_msg = sec.value.Error.ToString();
} else {
key = sec.value.Key;
}
// strategy
string strat_error_msg = null;
if (!strat.HasValue) {
strat_error_msg = "Strategy was not successfully saved";
} else if (!strat.Value.success) {
strat_error_msg = strat.Value.error_message;
} else if (strat.Value.value.Error != UpdateResult.Types.Error.Ok) {
strat_error_msg = strat.Value.value.Error.ToString();
}
// merge error msgs (result should be null if both errors are empty)
var error_msg = string.Join(Environment.NewLine, new[] { sec_error_msg, strat_error_msg }.ExceptNull());
return (key, error_msg.NullIfEmpty());
},
"Synthetic",
"creating synthetics");
}
public Task<uint?> create_synthetic(SecurityImmutable synthetic) {
if (synthetic.ContractCase != Security.ContractOneofCase.Synthetic)
return null;
@@ -106,10 +163,32 @@ namespace mbts.spark {
(r, success) => success,
"saving strategy");
public async Task<string[]> save_strategies(IEnumerable<(uint key, ExecutionStrategyImmutable strategy)> items) {
// Copy everything to a new list, to guarentee that it won't be altered during the op.
// The performance impact should be insignificant, as this should be a rare call.
var item_list = new List<(uint key, ExecutionStrategyImmutable strategy, int index)>(items.Select((item, index) => (item.key, item.strategy, index)));
string[] errors = new string[item_list.Count];
await Task.WhenAll(item_list.Select(impl));
return errors;
async Task impl((uint key, ExecutionStrategyImmutable strategy, int index) tup) {
var (key, strategy, index) = tup;
try {
var result = await _service.update_security_metadata_async(new Metadata {
SecurityKey = key,
Strategy = strategy.CloneToMutable()
});
if (!result.success)
errors[index] = result.error_message;
} catch (Exception ex) {
errors[index] = ex.ToString();
}
}
}
public async Task<bool> verify_name_is_unique(string name) {
var (result, success) = await strategy_tuple.FirstAsyncTask(SparkUtils.DefaultTimeOut);
name = name.Trim().ToLower();
return success && !result.Values.Any(st => st.md.security.Synthetic.Name.Trim().ToLower() == name);
}
}
}
}
@@ -1,6 +1,7 @@
using bts;
using bts.api;
using bts.shell;
using bts.shell.spreader;
using bts.spark;
using mbts.persist;
using mbts.ui;
@@ -18,7 +19,10 @@ using static bts.shell.SyntheticManagementWindowFactory;
namespace mbts.spark {
class SyntheticManagementWindow : SparkWindow<StartupData>, ISharedWindow {
const string _window_type = "SyntheticManagement";
const string
_window_type = "SyntheticManagement",
_import_title = "Import Synthetics";
static readonly TimeSpan _import_op_sec_map_timeout = TimeSpan.FromSeconds(30);
SingleValuePump<SyntheticManagementDialogVM> _vm = new SingleValuePump<SyntheticManagementDialogVM>();
StartupData _state;
OrdersModel _orders_model;
@@ -27,7 +31,6 @@ namespace mbts.spark {
IReadOnlyList<SparkCommand> _commands;
readonly IWindowSettingsManager<GridSettings> _settings_manager;
public SyntheticManagementWindow(SyntheticManagementWindowFactory factory, IBus bus, OrdersModel orders_model, StartupData state, IWindowSettingsManager<GridSettings> settings_manager)
: base("Synthetic Management", bus, factory, SparkCommands.ShowSyntheticManagement.icon) {
_orders_model = orders_model;
@@ -90,7 +93,11 @@ namespace mbts.spark {
var dialog = new ShellSettingsDialog { Title = "Synthetic Management Grid Settings", DataContext = vm };
vm.RequestClose += (s, e) => WindowUtilities.force_close(dialog);
return dialog;
}))
})),
new SparkCommandCommand(
"Import Synthetics...", Icons.Import, FileDialogCommand.open_file(import, extensions: SyntheticSecurityParser.file_extension)) {
show_in_toolbar = false
}
};
_subscriptions = Disposable.Create(
@@ -105,13 +112,16 @@ namespace mbts.spark {
r == null ? Observable.Return(new RowStrategy?()) :
_orders_model.spreader.security_strategy(r.security.Id).Select(strategy => RowStrategy.create(r.security, strategy));
uint select_security_id(RowModificationParams? rmp) => rmp.HasValue ? rmp.Value.security.Id : 0;
IImmutableSet<uint> select_security_id(RowModificationParams? rmp) => ImmutableHashSet.Create(rmp.HasValue ? rmp.Value.security.Id : 0);
(SecurityImmutable, ExecutionStrategyImmutable) select_row_strategy_tuple(RowStrategy? rs) => rs.HasValue ? (rs.Value.security, rs.Value.strategy) : default;
bool can_execute(RowModificationParams? rmp) => rmp.HasValue && !rmp.Value.has_working_orders;
_vm.value = new SyntheticManagementDialogVM(_bus, _orders_model, _settings_manager, _state.sorting_criteria, _state.filters ?? new FilterStates());
if (_view == null) _view = new SyntheticManagementView { DataContext = _vm.value };
else _view.DataContext = _vm.value;
void import(string path) =>
SyntheticImporter.import_from_file(path, _bus, _orders_model);
}
public override void Dispose() {
@@ -145,4 +155,4 @@ namespace mbts.spark {
new RowStrategy(security, strategy);
}
}
}
}
@@ -130,12 +130,7 @@ namespace mbts.spark {
if (valid) {
_synthetic.Synthetic.Legs.SetItems(leg_tuples.Select(l => l.leg));
_synthetic.Symbol = _deduce_symbol(_synthetic);
double tick_frac = _tick_factors.tick_unit / _tick_factors.tick_base;
_synthetic.ContractSpec.LowTick = tick_frac;
_synthetic.ContractSpec.HighTick = tick_frac;
_synthetic.ContractSpec.PriceBreak = double.MaxValue;
_synthetic.ContractSpec.MainFraction = (uint)MathUtils.factor_out(_tick_factors.tick_base, 10);
_synthetic.ContractSpec.PriceDisplayFormat = (uint)_tick_factors.display_digits();
_synthetic.ContractSpec = _tick_factors.to_spec();
uint? id = await model.create_synthetic(new SecurityImmutable(_synthetic));
if (id.HasValue && id != 0) {
if (await model.save_strategy(id.Value, get_strategy())) {
+6
View File
@@ -148,6 +148,11 @@ namespace mbts.spark {
OrderSecurityRootPair.from_order_security,
OrderSecurityHelper.root_pair_key_fn
).Cache();
// security order groups
security_order_groups = on_orders
.SelectKeyValue(tup => new OrderSecurity(tup), OrderSecurityHelper.key_fn)
.GroupTable(OrderSecurityHelper.key_fn, tup => tup.order.Def.SecurityKey)
.Cache();
// working account orders
var working_account_order_groups = working_orders.GroupTable(t => t.order.Key, t => new PNLKey(t.order.account_id(), t.order.security_key()));
// security account pnl
@@ -278,6 +283,7 @@ namespace mbts.spark {
public IObservable<TableUpdate<(AlgoData algo, AlgoDefinitionMetadata? meta), AlgoKey>> studio_algos_with_meta { get; }
public IObservable<TableUpdate<(SecurityImmutable?, ManualFillImmutable), int>> on_manual_fills_securities { get; }
public IObservable<TableUpdate<ManualFillTuple, int>> on_manual_fill_tuples { get; }
public IObservable<TableUpdate<TableUpdateGrouping<OrderSecurity, uint, uint>, uint>> security_order_groups { get; }
public AdminModel admin_model { get; }
public MBOService mbo_service => _mbo_service;
+1 -1
View File
@@ -79,7 +79,7 @@ namespace mbts.spark {
#endregion
public static ITag<uint> SyntheticDeleteTag { get; } = new SparkTag<uint>(nameof(SyntheticDeleteTag));
public static ITag<IImmutableSet<uint>> SyntheticDeleteTag { get; } = new SparkTag<IImmutableSet<uint>>(nameof(SyntheticDeleteTag));
public static ITag<Nothing> ShowGlobalAlertsTag { get; } = new SparkTag<Nothing>(nameof(ShowGlobalAlertsTag));
@@ -28,6 +28,9 @@ namespace mbts.ui.utility {
public static IReadOnlyObservableCollection<TResult> SelectObservable<T, TResult>(this ObservableCollection<T> source, Func<T, TResult> selector) =>
new SelectorWrapper<T, TResult>(source, source, selector);
public static IObservableCollection<TResult> SelectObservable<T, TResult>(this ObservableCollection<T> source, Func<T, TResult> selector, Func<TResult, T> reverse_selector) =>
new SelectorWrapper<T, TResult>(source, source, selector, reverse_selector);
public static IDisposable connect_sorted<T>(ObservableCollection<T> source, ObservableCollection<T> target, IComparer<T> comparer) {
target.sync_with(source.Ordered(comparer));
return source.Subscribe(on_source_collection_changed);
@@ -371,13 +374,15 @@ namespace mbts.ui.utility {
IEnumerator IEnumerable.GetEnumerator() => _source.GetEnumerator();
}
class SelectorWrapper<T, TResult> : IReadOnlyObservableCollection<TResult> {
readonly IReadOnlyList<T> _source_list;
class SelectorWrapper<T, TResult> : IObservableCollection<TResult>, IReadOnlyObservableCollection<TResult>, IList {
readonly IList<T> _source_list;
readonly Func<T, TResult> _selector;
readonly Func<TResult, T> _reverse_selector;
public SelectorWrapper(IReadOnlyList<T> source_list, INotifyCollectionChanged source_notifier, Func<T, TResult> selector) {
public SelectorWrapper(IList<T> source_list, INotifyCollectionChanged source_notifier, Func<T, TResult> selector, Func<TResult, T> reverse_selector = null) {
_source_list = source_list;
_selector = selector;
_reverse_selector = reverse_selector;
source_notifier.CollectionChanged += on_collection_changed;
void on_collection_changed(object sender, NotifyCollectionChangedEventArgs e) {
var cc = CollectionChanged;
@@ -398,17 +403,91 @@ namespace mbts.ui.utility {
selector((T)obj);
}
public TResult this[int index] => _selector(_source_list[index]);
public event NotifyCollectionChangedEventHandler CollectionChanged;
public TResult this[int index] {
get => _selector(_source_list[index]);
set => _source_list[index] = _reverse_selector(value);
}
public int Count => _source_list.Count;
public bool IsReadOnly => _reverse_selector == null;
public bool IsFixedSize => false;
public object SyncRoot => null;
public bool IsSynchronized => false;
public event NotifyCollectionChangedEventHandler CollectionChanged;
object IList.this[int index] {
get => this[index];
set => this[index] = (TResult)value;
}
public void Add(TResult item) =>
_source_list.Add(_reverse_selector(item));
public void Clear() =>
_source_list.Clear();
public bool Contains(TResult item) =>
IndexOf(item) >= 0;
public void CopyTo(TResult[] array, int arrayIndex) {
int stop = _source_list.Count;
for (int i = 0; i < stop; i++)
array[arrayIndex + i] = _selector(_source_list[i]);
}
public IEnumerator<TResult> GetEnumerator() {
foreach (var v in _source_list)
yield return _selector(v);
}
IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
public int IndexOf(TResult item) {
int stop = _source_list.Count;
for (int i = 0; i < stop; i++) {
if (EqualityComparer<TResult>.Default.Equals(_selector(_source_list[i]), item))
return i;
}
return -1;
}
public void Insert(int index, TResult item) =>
_source_list.Insert(index, _reverse_selector(item));
public bool Remove(TResult item) {
int i = IndexOf(item);
if (i >= 0) {
_source_list.RemoveAt(i);
return true;
}
return false;
}
public void RemoveAt(int index) =>
_source_list.RemoveAt(index);
IEnumerator IEnumerable.GetEnumerator() =>
GetEnumerator();
public int Add(object value) {
Add((TResult)value);
return Count - 1;
}
public bool Contains(object value) =>
Contains((TResult)value);
public int IndexOf(object value) =>
IndexOf((TResult)value);
public void Insert(int index, object value) =>
Insert(index, (TResult)value);
public void Remove(object value) =>
Remove((TResult)value);
public void CopyTo(Array array, int index) {
int stop = _source_list.Count;
for (int i = 0; i < stop; i++)
array.SetValue(_selector(_source_list[i]), index + i);
}
}
}
@@ -34,6 +34,13 @@ namespace mbts {
public static bool IsNaNOrInfinity(double d) => double.IsNaN(d) || double.IsInfinity(d);
public static bool IsNaNOrInfinityOr(double d, params double[] values) => IsNaNOrInfinity(d) || values.Contains(d);
public static bool IsOneOf(double d, params double[] values) => values.Contains(d);
public static bool IsNonZero(this double value) =>
value != 0 && !double.IsNaN(value) && !double.IsInfinity(value);
public static bool IsRealNonZero(this double value) =>
value > 0 && value != double.PositiveInfinity;
public static double CoerceNaN(double value) => CoerceNaN(value, 0.0);
public static double CoerceNaN(double value, double if_nan) => double.IsNaN(value) ? if_nan : value;
public static double CoerceNaNOrInfinity(double value) => CoerceNaNOrInfinity(value, 0.0);
@@ -57,4 +64,4 @@ namespace mbts {
public static double? nan_nullable(double value) =>
double.IsNaN(value) ? (double?)null : value;
}
}
}
@@ -3,6 +3,8 @@ using System;
using System.Globalization;
using bts;
using static bts.utils.MathUtils;
using bts.api;
using bts.utils;
namespace mbts {
static class TickExtensions {
@@ -110,6 +112,19 @@ namespace mbts {
return _round_tick(tuf, val);
}
public static ContractSpecification to_spec(this TickFactors tick) {
if (tick == null)
return null;
double tick_frac = tick.tick_unit_frac();
return new ContractSpecification {
LowTick = tick_frac,
HighTick = tick_frac,
PriceBreak = double.MaxValue,
MainFraction = (uint)factor_out(tick.tick_base, 10),
PriceDisplayFormat = (uint)tick.display_digits()
};
}
public static bool try_get_tickdiff(this RegionalTickFactors regional_tick, double x, double y, out int n_low, out int n_high) {
if (DoubleHelper.IsNaNOrInfinity(x) || DoubleHelper.IsNaNOrInfinity(y)) {
n_low = default;
@@ -41,12 +41,17 @@ namespace mbts.ui.shell {
else vm.set_error(property, message);
}
public static IObservable<bool> subscribe_has_errors(this INotifyDataErrorInfo vm) =>
public static IObservable<bool> subscribe_has_errors(this INotifyDataErrorInfo vm, bool start_immediately = false) =>
Observable.Create<bool>(o => {
bool last_value = vm.HasErrors;
if (start_immediately)
o.OnNext(vm.HasErrors);
vm.ErrorsChanged += on_errors_changed;
return Disposable.Create(() => vm.ErrorsChanged -= on_errors_changed);
void on_errors_changed(object sender, DataErrorsChangedEventArgs e) =>
o.OnNext(vm.HasErrors);
void on_errors_changed(object sender, DataErrorsChangedEventArgs e) {
if (vm.HasErrors != last_value)
o.OnNext(last_value = !last_value);
}
});
public static IObservable<T> SubscribeValue<T>(this IProperty<T> property) =>
@@ -881,4 +886,4 @@ namespace mbts.ui.shell {
return Disposable.Create(() => self.ErrorsChanged -= callback);
}
}
}
}
@@ -9,13 +9,18 @@
<SolidColorBrush x:Key="Ellipse.Pressed.Brush" Color="#FF3C77DD"/>
<SolidColorBrush x:Key="Ellipse.Disabled.Brush" Color="Gray"/>
<Style TargetType="c:ExpanderToggleButton" BasedOn="{StaticResource {x:Type ToggleButton}}">
<Setter Property="Background" Value="Transparent"/>
<Setter Property="BorderBrush" Value="Black"/>
<Setter Property="BorderThickness" Value="1"/>
<Setter Property="Padding" Value="3,0,0,0"/>
<Setter Property="Template">
<Setter.Value>
<ControlTemplate TargetType="ToggleButton">
<Border>
<ControlTemplate TargetType="c:ExpanderToggleButton">
<Border
Background="{TemplateBinding Background}"
BorderBrush="{TemplateBinding BorderBrush}"
BorderThickness="{TemplateBinding BorderThickness}"
>
<Grid Background="Transparent">
<Grid.ColumnDefinitions>
<ColumnDefinition Width="Auto"/>
@@ -26,6 +31,7 @@
x:Name="arrow"
Data="M0,0L3.5,3.5 0,7"
HorizontalAlignment="Center"
Margin="{TemplateBinding ArrowPadding}"
SnapsToDevicePixels="False"
Stroke="{StaticResource Path.Static.Brush}"
StrokeThickness="2"
@@ -8,5 +8,13 @@ namespace mbts.ui.controls {
class ExpanderToggleButton : ToggleButton {
static ExpanderToggleButton() =>
DefaultStyleKeyProperty.OverrideMetadata(typeof(ExpanderToggleButton), new FrameworkPropertyMetadata(typeof(ExpanderToggleButton)));
public static readonly DependencyProperty ArrowPaddingProperty =
WPFHelper.create_dp<Thickness, ExpanderToggleButton>(nameof(ArrowPadding));
public Thickness ArrowPadding {
get => (Thickness)GetValue(ArrowPaddingProperty);
set => SetValue(ArrowPaddingProperty, value);
}
}
}
}
@@ -265,6 +265,8 @@ namespace mbts.ui.controls {
}
protected override void OnPreviewMouseLeftButtonDown(MouseButtonEventArgs e) {
if (SelectionMode == SelectionMode.Single)
return;
var pt = e.GetPosition(this);
if (InputHitTest(pt) is UIElement el) {
var sb = new StringBuilderEx("beginning drag selection on ");
@@ -287,7 +289,6 @@ namespace mbts.ui.controls {
_log.info(sb.ToString());
}
}
base.OnPreviewMouseLeftButtonDown(e);
}
protected override void OnPreviewMouseUp(MouseButtonEventArgs e) {
@@ -24,6 +24,7 @@
<ComboBox
MinWidth="48"
IsEditable="True"
IsTextSearchEnabled="False"
DisplayMemberPath="value"
SelectedValuePath="value"
ItemsSource="{Binding TickUnitPresetsView, RelativeSource={RelativeSource TemplatedParent}}"
@@ -5,6 +5,7 @@ using System.Globalization;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Input;
namespace mbts.ui.controls {
@@ -19,6 +20,7 @@ namespace mbts.ui.controls {
// TextBox
TextBox _text_box;
IValueConverter _display_converter;
IDisposable _text_hooks = null;
// TickUpDown
LazyPropagator<TickUpDown, TickUpDownDouble> _explicit_props = new LazyPropagator<TickUpDown, TickUpDownDouble>((t, v) => {
@@ -64,12 +66,20 @@ namespace mbts.ui.controls {
public static readonly DependencyProperty MultiplierProperty = DependencyProperty.Register("Multiplier", typeof(double), typeof(TickUpDownDouble), new FrameworkPropertyMetadata(1.0));
public static readonly DependencyProperty FormatProperty = DependencyProperty.Register("Format", typeof(string), typeof(TickUpDownDouble));
public static readonly DependencyProperty TickDefaultValueProperty = DependencyProperty.Register(nameof(TickDefaultValue), typeof(double), typeof(TickUpDownDouble), new PropertyMetadata(0d));
public static readonly DependencyProperty DisplayConverterProperty = WPFHelper.create_dp<IValueConverter, TickUpDownDouble>(
nameof(DisplayConverter),
(o, v) => {
o._display_converter = v;
if (o._text_box != null)
o._text_box.Text = _format_value(o.Value, o.Format, v);
});
public double Value { get { return (double)GetValue(ValueProperty); } set { SetValue(ValueProperty, value); } }
public double Increment { get { return (double)GetValue(IncrementProperty); } set { SetValue(IncrementProperty, value); } }
public double Multiplier { get { return (double)GetValue(MultiplierProperty); } set { SetValue(MultiplierProperty, value); } }
public string Format { get { return GetValue(FormatProperty) as string; } set { SetValue(FormatProperty, value); } }
public double TickDefaultValue { get => (double)GetValue(TickDefaultValueProperty); set => SetValue(TickDefaultValueProperty, value); }
public IValueConverter DisplayConverter { get => GetValue(DisplayConverterProperty) as IValueConverter; set => SetValue(DisplayConverterProperty, value); }
// explicit props
public bool EnableArrowKeyTick { get => _enable_arrow_key_tick.value; set => _enable_arrow_key_tick.value = value; }
public ModifierKeys ArrowKeyTickModifiers { get => _arrow_key_tick_modifiers.value; set => _arrow_key_tick_modifiers.value = value; }
@@ -84,7 +94,7 @@ namespace mbts.ui.controls {
_tick_up_down.TickDownCommand = new DelegateCommand(_tick_down);
// TextBox
_text_box = this.assert_template_child<TextBox>("PART_TextBox");
_text_box.Text = _format_value(Value, Format);
_text_box.Text = _format_value(Value, Format, _display_converter);
if (_text_box.InputBindings.Count == 0) {
// this is a workaround to get KeyBindings to work since the TextBox blocks them while it has keyboard focus.
// only do this if count == 0, to avoid interfering with keybindings explicitly set in a custom ControlTemplate.
@@ -93,7 +103,9 @@ namespace mbts.ui.controls {
push_text_to_value();
_text_hooks = _text_box.SubscribeTextChanged((s, e) => push_text_to_value());
void push_text_to_value() {
if (double.TryParse(_text_box.Text, out double d)) {
if (_display_converter != null && _display_converter.ConvertBack(_text_box.Text, typeof(double), null, CultureInfo.CurrentCulture) is double d) {
SetCurrentValue(ValueProperty, d);
} else if (double.TryParse(_text_box.Text, out d)) {
SetCurrentValue(ValueProperty, d);
} else {
SetCurrentValue(ValueProperty, double.NaN);
@@ -113,7 +125,10 @@ namespace mbts.ui.controls {
} else Value = TickDefaultValue;
}
static string _format_value(double value, string format) =>
format == null ? value.ToString() : value.ToString(format, CultureInfo.CurrentCulture);
// use display_converter if non-null, otherwise use format
static string _format_value(double value, string format, IValueConverter display_converter = null) =>
display_converter != null ?
display_converter.Convert(value, typeof(string), null, CultureInfo.CurrentCulture)?.ToString() :
(format == null ? value.ToString() : value.ToString(format, CultureInfo.CurrentCulture));
}
}
@@ -11,6 +11,8 @@ namespace mbts.ui.converters
private Visibility _visfalse = Visibility.Collapsed;
public Visibility VisibilityForFalse { get { return _visfalse; } set { _visfalse = value; } }
public static BooleanToVisibilityConverter Instance => new BooleanToVisibilityConverter();
public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture) {
bool flag = false;
if (value is bool) {
@@ -0,0 +1,56 @@
using System;
using System.Globalization;
using System.Windows;
using System.Windows.Data;
namespace mbts.ui.converters {
[ValueConversion(typeof(SizeToContent), typeof(double))]
abstract class WindowSizeThresholdConverter : IValueConverter {
readonly SizeToContent _size_to_content_flag;
protected WindowSizeThresholdConverter(SizeToContent size_to_content_flag) =>
_size_to_content_flag = size_to_content_flag;
public double SizeToContentThreshold { get; set; } = double.NaN;
public double Threshold { get; set; }
public object Convert(object value, Type targetType, object parameter, CultureInfo culture) {
if (value is SizeToContent stc) {
if ((stc & _size_to_content_flag) == _size_to_content_flag) {
if (double.IsNaN(SizeToContentThreshold)) {
if (parameter is double d)
return d;
} else {
return SizeToContentThreshold;
}
}
}
return Threshold;
}
public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture) =>
throw new NotSupportedException();
}
[ValueConversion(typeof(SizeToContent), typeof(double))]
sealed class WindowMinWidthConverter : WindowSizeThresholdConverter {
public WindowMinWidthConverter() : base(SizeToContent.Width) { }
}
[ValueConversion(typeof(SizeToContent), typeof(double))]
sealed class WindowMaxWidthConverter : WindowSizeThresholdConverter {
public WindowMaxWidthConverter() : base(SizeToContent.Width) =>
Threshold = double.PositiveInfinity;
}
[ValueConversion(typeof(SizeToContent), typeof(double))]
sealed class WindowMinHeightConverter : WindowSizeThresholdConverter {
public WindowMinHeightConverter() : base(SizeToContent.Height) { }
}
[ValueConversion(typeof(SizeToContent), typeof(double))]
sealed class WindowMaxHeightConverter : WindowSizeThresholdConverter {
public WindowMaxHeightConverter() : base(SizeToContent.Height) =>
Threshold = double.PositiveInfinity;
}
}
@@ -1,18 +1,23 @@
using mbts.config;
using mbts.ui.controls;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Windows;
using System.Windows.Forms;
namespace mbts.ui.dpi {
public static class HighDpiExtensions {
public static readonly double dpi_ratio;
public static readonly double
dpi_ratio,
pixel_unit;
public static readonly float fdpi_ratio;
static HighDpiExtensions() {
dpi_ratio = Configuration.get<bts.config.System>().dpi_ratio;
pixel_unit = 1.0 / dpi_ratio;
fdpi_ratio = (float)dpi_ratio;
}
@@ -119,5 +124,22 @@ namespace mbts.ui.dpi {
}
}
#endregion
public static double RoundLayoutValue(this double value) =>
RoundLayoutValue(value, dpi_ratio);
public static double RoundLayoutValue(double value, double dpi_scale) {
if (DoubleUtil.AreClose(dpi_scale, 1.0))
return Math.Round(value);
double result = Math.Round(value * dpi_scale) / dpi_scale;
return DoubleHelper.IsNaNOrInfinity(result) || DoubleUtil.AreClose(result, double.MaxValue) ? value : result;
}
public static Thickness RoundToLayout(this Thickness thickness) =>
new Thickness(
thickness.Left.RoundLayoutValue(),
thickness.Top.RoundLayoutValue(),
thickness.Right.RoundLayoutValue(),
thickness.Bottom.RoundLayoutValue());
}
}
@@ -0,0 +1,13 @@
using mbts.ui.dpi;
namespace mbts.ui {
class DPIDoubleExtension : DoubleExtension {
public DPIDoubleExtension()
: base() =>
RoundingUnit = HighDpiExtensions.dpi_ratio;
public DPIDoubleExtension(double value)
: base(value) =>
RoundingUnit = HighDpiExtensions.dpi_ratio;
}
}
@@ -2,11 +2,9 @@
using System.ComponentModel;
using System.Windows.Markup;
namespace mbts.ui
{
namespace mbts.ui {
[MarkupExtensionReturnType(typeof(double))]
public class DoubleExtension : MarkupExtension
{
class DoubleExtension : MarkupExtension {
public DoubleExtension() : this(Double.NaN) { }
public DoubleExtension(double Value) {
@@ -17,9 +15,11 @@ namespace mbts.ui
[TypeConverter(typeof(DoubleStringTypeConverter))]
public double Value { get; set; }
public override object ProvideValue(IServiceProvider serviceProvider) {
return Value;
}
[TypeConverter(typeof(DoubleStringTypeConverter))]
public double RoundingUnit { get; set; }
public override object ProvideValue(IServiceProvider serviceProvider) =>
RoundingUnit.IsRealNonZero() ? Math.Round(Value * RoundingUnit) / RoundingUnit : Value;
}
internal class DoubleStringTypeConverter : TypeConverter
@@ -1,4 +1,5 @@
using mbts.utils;
using bts.utils;
using mbts.utils;
using System;
using System.Windows;
using System.Windows.Controls;
@@ -199,5 +200,44 @@ namespace mbts.ui {
public static bool GetFocusOnLoaded(DependencyObject d) => (bool)d.GetValue(FocusOnLoadedProperty);
public static void SetFocusOnLoaded(DependencyObject d, bool value) => d.SetValue(FocusOnLoadedProperty, value);
#endregion
#region MirrorLayout
static readonly DependencyProperty[] _layout_props = new[] {
FrameworkElement.HeightProperty,
FrameworkElement.WidthProperty,
FrameworkElement.MarginProperty,
Control.PaddingProperty,
FrameworkElement.HorizontalAlignmentProperty,
Control.HorizontalContentAlignmentProperty,
FrameworkElement.VerticalAlignmentProperty,
Control.VerticalContentAlignmentProperty
};
public static readonly DependencyProperty MirrorLayoutForProperty =
DependencyProperty.RegisterAttached("MirrorLayoutFor", typeof(FrameworkElement), typeof(Behavior),
new PropertyMetadata(OnMirrorLayoutForChanged));
static void OnMirrorLayoutForChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) {
var target = new LazyCast<FrameworkElement, DependencyObject>(d);
if (e.OldValue is FrameworkElement old_src) {
target.value.clear_bindings(_layout_props);
}
if (e.NewValue is FrameworkElement new_src) {
target.value.bind(FrameworkElement.WidthProperty, new_src, FrameworkElement.ActualWidthProperty);
target.value.bind(FrameworkElement.HeightProperty, new_src, FrameworkElement.ActualHeightProperty);
target.value.bind(FrameworkElement.MarginProperty, new_src, FrameworkElement.MarginProperty);
target.value.bind(FrameworkElement.HorizontalAlignmentProperty, new_src, FrameworkElement.HorizontalAlignmentProperty);
target.value.bind(FrameworkElement.VerticalAlignmentProperty, new_src, FrameworkElement.VerticalAlignmentProperty);
if (target.value is Control && new_src is Control) {
target.value.bind(Control.PaddingProperty, new_src, Control.PaddingProperty);
target.value.bind(Control.HorizontalContentAlignmentProperty, new_src, Control.HorizontalContentAlignmentProperty);
target.value.bind(Control.VerticalContentAlignmentProperty, new_src, Control.VerticalContentAlignmentProperty);
}
}
}
public static FrameworkElement GetMirrorLayoutFor(DependencyObject d) => d.GetValue(MirrorLayoutForProperty) as FrameworkElement;
public static void SetMirrorLayoutFor(DependencyObject d, FrameworkElement value) => d.SetValue(MirrorLayoutForProperty, value);
#endregion
}
}
}
@@ -104,6 +104,9 @@ namespace mbts.spark {
}
}
public static RegionalTickFactors get_tick_factors(ContractSpecificationImmutable spec) =>
TickStore.get(spec);
public static double tickup(this ContractSpecificationImmutable spec, double value) =>
TickStore.get(spec).tickup(value);
@@ -11,6 +11,22 @@ namespace mbts.spark {
public static string strip_name(this SecurityImmutable security) => security.HasIce ? security.Ice.StripName : string.Empty;
public static string mic_code(this SecurityImmutable security) => security.HasIce ? security.Ice.MicCode : string.Empty;
public static bool is_exchange_security(this SecurityImmutable? security) =>
security.HasValue && is_exchange_security(security.Value);
public static bool is_exchange_security(this SecurityImmutable security) {
switch (security.Exchange) {
case Venue.Bts:
case Venue.Unset: return false;
}
switch (security.ContractCase) {
case Security.ContractOneofCase.Future:
case Security.ContractOneofCase.Spread:
return true;
default: return false;
}
}
public static class EqualityComparer {
public static readonly IEqualityComparer<SecurityMD> MDComparer = bts.utils.EqualityComparer.Create<SecurityMD>(Equals, GetHashCode);
public static bool Equals(SecurityMD x, SecurityMD y) => x.security.Id == y.security.Id;
@@ -0,0 +1,107 @@
using bts.collections;
using mbts;
using mbts.collections;
using mbts.ui;
using mbts.ui.shell;
using mbts.ui.utility;
using mbts.utils;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Linq;
using System.Reactive.Linq;
using System.Windows.Data;
using System.Windows.Input;
namespace bts.utils {
/// <summary>
/// <typeparamref name="TConflictUnit"/> will often be the same as <typeparamref name="TRow"/>; they are distinguishable to support
/// cases where the same conflict resolution logic can be applied to more than 1 field (such as multiple contract legs in a synthetic security).
/// </summary>
/// <typeparam name="TConflictUnit">Represents the type of units to which conflict resolutions will be applied.</typeparam>
/// <typeparam name="TRow">Represents the type of unit that is expressed by a line of text.</typeparam>
/// <typeparam name="TComponent">The parameter type identifier (should be an enum).</typeparam>
class ImportConflictsVM<TConflictUnit, TRow, TComponent> : DisposableViewModelBase, IRequestViewClose where TComponent : struct {
readonly RefCountMap<TRow> _conflicts = new RefCountMap<TRow>();
readonly ObservableCollection<RowItem> _row_items = new ObservableCollection<RowItem>();
IReadOnlyDictionary<uint, SecurityMD> _security_map = DictionaryHelper.empty<uint, SecurityMD>();
public ImportConflictsVM(int num_synthetics, Func<TConflictUnit, TRow> get_owning_row)
: this(num_synthetics, get_owning_row, EqualityComparer<TRow>.Default) { }
public ImportConflictsVM(int num_rows, Func<TConflictUnit, TRow> get_owning_row, IEqualityComparer<TRow> row_comparer) {
conflicts = _row_items.SelectObservable(ri => ri.value, r => new RowItem(r, get_owning_row, row_comparer));
conflicts_view = CollectionViewSource.GetDefaultView(conflicts);
ok_cmd = new DelegateCommand(() => {
committed?.Invoke();
RequestClose?.Invoke(this, EventArgs.Empty);
});
cancel_cmd = new DelegateCommand(() => RequestClose?.Invoke(this, new EventArgs()));
this.num_rows = num_rows;
_dispose = ObservableAutoWrapper.connect_item_hooks(_row_items, ri =>
ri.value.subscribe_has_error().Subscribe(has_error => {
if ((has_error ? ri.affected_keys.Count(_conflicts.increment_adds_key) : ri.affected_keys.Count(_conflicts.decrement_removes_key)) > 0) {
RaisePropertyChanged(nameof(num_successfully_parsed_rows));
}
}));
}
public event Action committed;
public event EventHandler RequestClose;
public IObservableCollection<ImportConflictRowVM<TConflictUnit, TComponent>> conflicts { get; }
public ICollectionView conflicts_view { get; }
public int num_rows { get; }
public int num_successfully_parsed_rows => num_rows - _conflicts.Count;
// commands
public ICommand ok_cmd { get; }
public ICommand cancel_cmd { get; }
readonly struct RowItem {
readonly Lazy<List<TRow>> _affected_rows;
public RowItem(ImportConflictRowVM<TConflictUnit, TComponent> value, Func<TConflictUnit, TRow> get_owning_row, IEqualityComparer<TRow> row_comparer) {
this.value = value;
_affected_rows = new Lazy<List<TRow>>(() => value.affected_parts.Select(get_owning_row).Distinct(row_comparer).ToList());
}
public ImportConflictRowVM<TConflictUnit, TComponent> value { get; }
public List<TRow> affected_keys => _affected_rows.Value;
}
}
class ImportConflictRowVM<T, TComponent> : ViewModelBase, ITemplateSelectorKey where TComponent : struct {
readonly DelegateProperty<bool> _has_error;
object _value;
string _text;
public ImportConflictRowVM(TComponent component, string text, IReadOnlyCollection<T> affected_parts, object error_value, object value, int num_affected_rows) {
this.component = component;
this.text = text;
this.affected_parts = affected_parts;
this.num_affected_rows = num_affected_rows;
_value = value;
_has_error = backing(nameof(has_error), () => Equals(this.value, error_value));
}
public TComponent component { get; }
public string text { get => _text; set => Set(ref _text, value); }
public IReadOnlyCollection<T> affected_parts { get; }
public int num_affected_rows { get; }
public object value {
get => _value;
set {
if (Set(ref _value, value))
_has_error.refresh();
}
}
public bool has_error => _has_error.Value;
string ITemplateSelectorKey.key => component.ToString();
public virtual void on_conflicts_resolved() { }
public IObservable<bool> subscribe_has_error() =>
_has_error.observe_current(true);
}
}
+112 -2
View File
@@ -24,6 +24,18 @@ namespace mbts.ui.utility {
return Enum.GetValues(t);
}
public static object add_flags(object value, object flags) =>
EnumDescriptorStore.descriptor(value.GetType()).add_flags(value, flags);
public static object remove_flags(object value, object flags) =>
EnumDescriptorStore.descriptor(value.GetType()).add_flags(value, flags);
public static T add_flags<T>(T value, T flags) where T : struct =>
(T)EnumDescriptorStore<T>.descriptor.add_flags(value, flags);
public static T remove_flags<T>(T value, T flags) where T : struct =>
(T)EnumDescriptorStore<T>.descriptor.remove_flags(value, flags);
public static T parse<T>(string name) where T : struct /*(Enum, more specifically)*/ {
if (!typeof(T).IsEnum) throw new InvalidOperationException($"{typeof(T)} is not an enum type.");
if (!Enum.TryParse(name, true, out T result)) throw new ArgumentException(nameof(name), "Does not match any of the values");
@@ -103,9 +115,16 @@ namespace mbts.ui.utility {
struct EnumDescriptor {
public readonly Func<object, object, bool> has_flags;
public readonly Func<object, object, object> add_flags, remove_flags;
public EnumDescriptor(Func<object, object, bool> has_flags) =>
public EnumDescriptor(
Func<object, object, bool> has_flags,
Func<object, object, object> add_flags,
Func<object, object, object> remove_flags) {
this.has_flags = has_flags;
this.add_flags = add_flags;
this.remove_flags = remove_flags;
}
}
static class EnumDescriptorStore {
@@ -129,83 +148,174 @@ namespace mbts.ui.utility {
static EnumDescriptorStore() {
Func<object, object, bool> has_flags;
Func<object, object, object> add_flags, remove_flags;
if (!typeof(T).IsEnum) {
// N/A
has_flags = Impl.as_none_has_flags;
add_flags = Impl.as_none_add_flags;
remove_flags = Impl.as_none_remove_flags;
}
var numeric_type = Enum.GetUnderlyingType(typeof(T));
if (numeric_type == typeof(byte)) {
// byte
has_flags = Impl.as_byte_has_flags;
add_flags = Impl.as_byte_add_flags;
remove_flags = Impl.as_byte_remove_flags;
} else if (numeric_type == typeof(short)) {
// short
has_flags = Impl.as_int16_has_flags;
add_flags = Impl.as_int16_add_flags;
remove_flags = Impl.as_int16_remove_flags;
} else if (numeric_type == typeof(int)) {
// int
has_flags = Impl.as_int32_has_flags;
add_flags = Impl.as_int32_add_flags;
remove_flags = Impl.as_int32_remove_flags;
} else if (numeric_type == typeof(long)) {
// long
has_flags = Impl.as_int64_has_flags;
add_flags = Impl.as_int64_add_flags;
remove_flags = Impl.as_int64_remove_flags;
} else if (numeric_type == typeof(ushort)) {
// ushort
has_flags = Impl.as_uint16_has_flags;
add_flags = Impl.as_uint16_add_flags;
remove_flags = Impl.as_uint16_remove_flags;
} else if (numeric_type == typeof(uint)) {
// uint
has_flags = Impl.as_uint32_has_flags;
add_flags = Impl.as_uint32_add_flags;
remove_flags = Impl.as_uint32_remove_flags;
} else if (numeric_type == typeof(ulong)) {
// ulong
has_flags = Impl.as_uint64_has_flags;
add_flags = Impl.as_uint64_add_flags;
remove_flags = Impl.as_uint64_remove_flags;
} else {
// ?
has_flags = Impl.as_none_has_flags;
add_flags = Impl.as_none_add_flags;
remove_flags = Impl.as_none_remove_flags;
}
descriptor = new EnumDescriptor(has_flags);
descriptor = new EnumDescriptor(has_flags, add_flags, remove_flags);
}
static class Impl {
public static bool as_none_has_flags(object value, object flags) => false;
public static object as_none_add_flags(object value, object flags) => value;
public static object as_none_remove_flags(object value, object flags) => value;
// byte
public static bool as_byte_has_flags(object value, object flags) {
byte value_as_byte = (byte)Convert.ChangeType(value, typeof(byte));
byte flags_as_byte = (byte)Convert.ChangeType(flags, typeof(byte));
return (value_as_byte & flags_as_byte) == flags_as_byte;
}
public static object as_byte_add_flags(object value, object flags) {
byte value_as_byte = (byte)Convert.ChangeType(value, typeof(byte));
byte flags_as_byte = (byte)Convert.ChangeType(flags, typeof(byte));
return value_as_byte | flags_as_byte;
}
public static object as_byte_remove_flags(object value, object flags) {
byte value_as_byte = (byte)Convert.ChangeType(value, typeof(byte));
byte flags_as_byte = (byte)Convert.ChangeType(flags, typeof(byte));
return (value_as_byte | flags_as_byte) ^ flags_as_byte;
}
// short
public static bool as_int16_has_flags(object value, object flags) {
short value_as_short = (short)Convert.ChangeType(value, typeof(short));
short flags_as_short = (short)Convert.ChangeType(flags, typeof(short));
return (value_as_short & flags_as_short) == flags_as_short;
}
public static object as_int16_add_flags(object value, object flags) {
short value_as_short = (short)Convert.ChangeType(value, typeof(short));
short flags_as_short = (short)Convert.ChangeType(flags, typeof(short));
return value_as_short | flags_as_short;
}
public static object as_int16_remove_flags(object value, object flags) {
short value_as_short = (short)Convert.ChangeType(value, typeof(short));
short flags_as_short = (short)Convert.ChangeType(flags, typeof(short));
return (value_as_short | flags_as_short) ^ flags_as_short;
}
// int
public static bool as_int32_has_flags(object value, object flags) {
int value_as_byte = (int)Convert.ChangeType(value, typeof(int));
int flags_as_byte = (int)Convert.ChangeType(flags, typeof(int));
return (value_as_byte & flags_as_byte) == flags_as_byte;
}
public static object as_int32_add_flags(object value, object flags) {
int value_as_int = (int)Convert.ChangeType(value, typeof(int));
int flags_as_int = (int)Convert.ChangeType(flags, typeof(int));
return value_as_int | flags_as_int;
}
public static object as_int32_remove_flags(object value, object flags) {
int value_as_int = (int)Convert.ChangeType(value, typeof(int));
int flags_as_int = (int)Convert.ChangeType(flags, typeof(int));
return (value_as_int | flags_as_int) ^ flags_as_int;
}
// long
public static bool as_int64_has_flags(object value, object flags) {
long value_as_long = (long)Convert.ChangeType(value, typeof(long));
long flags_as_long = (long)Convert.ChangeType(flags, typeof(long));
return (value_as_long & flags_as_long) == flags_as_long;
}
public static object as_int64_add_flags(object value, object flags) {
long value_as_long = (long)Convert.ChangeType(value, typeof(long));
long flags_as_long = (long)Convert.ChangeType(flags, typeof(long));
return value_as_long | flags_as_long;
}
public static object as_int64_remove_flags(object value, object flags) {
long value_as_long = (long)Convert.ChangeType(value, typeof(long));
long flags_as_long = (long)Convert.ChangeType(flags, typeof(long));
return (value_as_long | flags_as_long) ^ flags_as_long;
}
// ushort
public static bool as_uint16_has_flags(object value, object flags) {
ushort value_as_ushort = (ushort)Convert.ChangeType(value, typeof(ushort));
ushort flags_as_ushort = (ushort)Convert.ChangeType(flags, typeof(ushort));
return (value_as_ushort & flags_as_ushort) == flags_as_ushort;
}
public static object as_uint16_add_flags(object value, object flags) {
ushort value_as_ushort = (ushort)Convert.ChangeType(value, typeof(ushort));
ushort flags_as_ushort = (ushort)Convert.ChangeType(flags, typeof(ushort));
return value_as_ushort | flags_as_ushort;
}
public static object as_uint16_remove_flags(object value, object flags) {
ushort value_as_ushort = (ushort)Convert.ChangeType(value, typeof(ushort));
ushort flags_as_ushort = (ushort)Convert.ChangeType(flags, typeof(ushort));
return (value_as_ushort | flags_as_ushort) ^ flags_as_ushort;
}
// uint
public static bool as_uint32_has_flags(object value, object flags) {
uint value_as_uint = (uint)Convert.ChangeType(value, typeof(uint));
uint flags_as_uint = (uint)Convert.ChangeType(flags, typeof(uint));
return (value_as_uint & flags_as_uint) == flags_as_uint;
}
public static object as_uint32_add_flags(object value, object flags) {
uint value_as_uint = (uint)Convert.ChangeType(value, typeof(uint));
uint flags_as_uint = (uint)Convert.ChangeType(flags, typeof(uint));
return value_as_uint | flags_as_uint;
}
public static object as_uint32_remove_flags(object value, object flags) {
uint value_as_uint = (uint)Convert.ChangeType(value, typeof(uint));
uint flags_as_uint = (uint)Convert.ChangeType(flags, typeof(uint));
return (value_as_uint | flags_as_uint) ^ flags_as_uint;
}
// ulong
public static bool as_uint64_has_flags(object value, object flags) {
ulong value_as_ulong = (ulong)Convert.ChangeType(value, typeof(ulong));
ulong flags_as_ulong = (ulong)Convert.ChangeType(flags, typeof(ulong));
return (value_as_ulong & flags_as_ulong) == flags_as_ulong;
}
public static object as_uint64_add_flags(object value, object flags) {
ulong value_as_ulong = (ulong)Convert.ChangeType(value, typeof(ulong));
ulong flags_as_ulong = (ulong)Convert.ChangeType(flags, typeof(ulong));
return value_as_ulong | flags_as_ulong;
}
public static object as_uint64_remove_flags(object value, object flags) {
ulong value_as_ulong = (ulong)Convert.ChangeType(value, typeof(ulong));
ulong flags_as_ulong = (ulong)Convert.ChangeType(flags, typeof(ulong));
return (value_as_ulong | flags_as_ulong) ^ flags_as_ulong;
}
}
}
}
@@ -1,13 +1,11 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using mbts.ui.shell;
using System;
namespace mbts.ui.utility {
class SelectableItemVM<T> : ViewModelBase {
T _value;
bool _is_selected;
namespace mbts.ui.utility
{
public class SelectableItemVM<T>
{
public SelectableItemVM()
: this(default(T), false) { }
@@ -15,12 +13,27 @@ namespace mbts.ui.utility
: this(value, false) { }
public SelectableItemVM(T value, bool is_selected) {
this.value = value;
this.is_selected = is_selected;
_value = value;
_is_selected = is_selected;
}
public T value { get; set; }
public bool is_selected { get; set; }
public event Action<bool> is_selected_changed;
public T value {
get => _value;
set => Set(ref _value, value);
}
public bool is_selected {
get => _is_selected;
set {
if (_is_selected != value) {
_is_selected = value;
is_selected_changed?.Invoke(value);
RaisePropertyChanged();
}
}
}
public override string ToString() {
return value.ToString();
@@ -16,6 +16,13 @@ namespace mbts.ui {
static class WPFHelper {
public delegate void PropertyChangedCallback<TValue, TOwner>(TOwner owner, TValue old_value, TValue new_value);
public static void bind(this DependencyObject target, DependencyProperty target_property, object source, params DependencyProperty[] source_properties) {
BindingOperations.SetBinding(target, target_property, new Binding {
Path = new PropertyPath(string.Join(".", Enumerable.Range(0, source_properties.Length).Select(i => $"({i})")), source_properties),
Source = source
});
}
public static DependencyProperty create_dp<TOwner>(string name, Action<TOwner, object> callback, object default_value = null) =>
DependencyProperty.Register(name, typeof(object), typeof(TOwner), new PropertyMetadata(default_value, (d, e) => callback(ConvertUtils.try_convert<TOwner>(d), e.NewValue)));
@@ -7,7 +7,7 @@ using System.Windows;
namespace mbts.ui.utility
{
public static class WindowUtilities
static class WindowUtilities
{
public static void make_visible(Window window) {
window.WindowState = WindowState.Normal;
@@ -42,6 +42,69 @@ namespace mbts.ui.utility
}
}
/// <summary>
/// If <paramref name="vm"/> is of type <see cref="IRequestViewClose"/>, a callback will be added to the <see cref="IRequestViewClose.RequestClose"/> event that closes the <paramref name="window"/>.
/// If <paramref name="vm"/> is of type <see cref="IDisposable"/>, it will be disposed when the window is closed.
/// </summary>
/// <param name="window">The window to connect.</param>
/// <param name="vm">The viewmodel to connect.</param>
/// <returns>An <see cref="IDisposable"/> that will close the window, dispose the vm (if it implements <see cref="IDisposable"/>), and remove any event callbacks that were added.</returns>
public static IDisposable connect_vm(Window window, object vm) =>
connect_vm(window, vm as IRequestViewClose, vm as IDisposable);
/// <summary>
/// Closes the window in response to <paramref name="request_view_close"/>'s <see cref="IRequestViewClose.RequestClose"/> event,
/// and disposes the specefied <see cref="IDisposable"/> when the window is closed. Note: either parameter may be null.
/// </summary>
/// <param name="request_view_close">The 'request close' event source.</param>
/// <param name="dispose">The <see cref="IDisposable"/> to dispose when the window closes.</param>
/// <returns>An <see cref="IDisposable"/> that will close the window, dispose the vm (if it implements <see cref="IDisposable"/>), and remove any event callbacks that were added.</returns>
public static IDisposable connect_vm(Window window, IRequestViewClose request_view_close, IDisposable dispose) {
if (window == null)
throw new ArgumentNullException(nameof(window));
if (request_view_close != null) {
request_view_close.RequestClose += on_request_close;
}
window.Closed += on_closed;
return Disposable.Create(destroy_all);
void destroy_all() {
destroy_vm();
destroy_win();
}
void destroy_vm() {
if (request_view_close != null) {
request_view_close.RequestClose -= on_request_close;
request_view_close = null;
}
if (dispose != null) {
dispose.Dispose();
dispose = null;
}
}
void destroy_win() {
if (window != null) {
window.Closed -= on_closed;
force_close(window);
window = null;
}
}
void on_closed(object sender, EventArgs e) {
destroy_vm();
if (window != null) {
window.Closed -= on_closed;
window = null;
}
}
void on_request_close(object sender, EventArgs e) =>
destroy_all();
}
public static IDisposable listen_for_close_requests(Window window) {
var rvc_handler = new EventHandler((s, e) => force_close(window));
IDisposable hook = null;
@@ -149,4 +149,41 @@ namespace mbts
_dispose_once();
}
}
/// <summary>
/// An [immutable]<see cref="IDisposable"/> with +/- operators to add/remove specific actions and other <see cref="IDisposable"/>s.
/// </summary>
class DisposableCombo : IDisposable {
readonly Action _dispose;
public DisposableCombo() { }
public DisposableCombo(Action action) =>
_dispose = action;
public DisposableCombo(params IDisposable[] disposables) =>
_dispose = new Action(() => {
for (int i = 0; i < disposables.Length; i++)
disposables[i].Dispose();
});
public void Dispose() =>
_dispose?.Invoke();
public static DisposableCombo operator +(DisposableCombo aggregate_disposable, IDisposable dispose) =>
aggregate_disposable + dispose.Dispose;
public static DisposableCombo operator -(DisposableCombo aggregate_disposable, IDisposable dispose) =>
aggregate_disposable - dispose.Dispose;
public static DisposableCombo operator +(DisposableCombo aggregate_disposable, Action action) =>
action == null ?
aggregate_disposable :
new DisposableCombo(aggregate_disposable._dispose + action);
public static DisposableCombo operator -(DisposableCombo aggregate_disposable, Action action) =>
action == null ?
aggregate_disposable :
new DisposableCombo(aggregate_disposable._dispose - action);
}
}
@@ -607,6 +607,13 @@ namespace System.Collections.Generic {
yield return ConvertUtils.try_convert<TResult>(obj);
}
public static IEnumerable<(T1, T2)> Zip<T1, T2>(this IEnumerable<T1> source, IEnumerable<T2> other) {
using (var sen = source.GetEnumerator())
using (var oen = other.GetEnumerator())
while (sen.MoveNext() && oen.MoveNext())
yield return (sen.Current, oen.Current);
}
struct EnumerableCount<T> {
readonly ICollection<T> _collection;
readonly IReadOnlyCollection<T> _ro_collection;
+44
View File
@@ -1,5 +1,6 @@
using mbts.utils;
using System;
using System.Collections;
using System.Collections.Generic;
namespace bts.utils {
@@ -8,6 +9,7 @@ namespace bts.utils {
if (array.Length > size) {
T[] trimmed = new T[size];
Array.Copy(array, trimmed, size);
array = trimmed;
}
}
@@ -45,6 +47,48 @@ namespace bts.utils {
return rv;
}
/// <summary>
/// Attemps to get an exact item count (to initialize the resultant array with an exact length, thus avoiding unneccessary allocations) by checking if the specified source implements <see cref="ICollection{T}"/>, <see cref="IReadOnlyCollection{T}"/>, or <see cref="ICollection"/>.
/// </summary>
/// <typeparam name="T">The type of elements.</typeparam>
/// <param name="source">The source that will be copied to the resultant array.</param>
/// <returns>An array containing the elements from the specified source.</returns>
public static T[] clone_optimized<T>(IEnumerable<T> source) {
if (source == null)
return Array.Empty<T>();
T[] result;
if (source is ICollection<T> collection) {
result = new T[collection.Count];
collection.CopyTo(result, 0);
} else if (source is IReadOnlyCollection<T> ro_collection) {
result = new T[ro_collection.Count];
int i = 0;
foreach (var v in ro_collection)
result[i++] = v;
} else if (source is ICollection ng_collection) {
result = new T[ng_collection.Count];
int i = 0;
foreach (var v in source)
result[i++] = v;
} else {
int i = 0;
using (var en = source.GetEnumerator()) {
if (en.MoveNext()) {
result = new[] { en.Current };
i = 1;
while (en.MoveNext()) {
ensure_capacity(ref result, i + 1);
result[i++] = en.Current;
}
trim(ref result, i);
} else {
return Array.Empty<T>();
}
}
}
return result;
}
public static void insert<T>(ref T[] array, int index, T value, ref int size) {
// validate size/index
if (size < 0)
+47
View File
@@ -0,0 +1,47 @@
using System;
namespace bts.utils {
static class Lazy {
public static Lazy<T> create<T>() where T : new() =>
new Lazy<T>(_CreateDefault<T>.impl);
static class _CreateDefault<T> where T : new() {
public static readonly Func<T> impl = () => new T();
}
}
static class LazyCast {
public static LazyCast<T> create<T>(object obj) =>
new LazyCast<T>(obj);
}
readonly struct LazyCast<T> {
readonly Lazy<T> _lazy;
public LazyCast(object obj) {
_lazy = new Lazy<T>(impl);
T impl() =>
(T)obj;
}
public T value => _lazy.Value;
public static implicit operator T(LazyCast<T> lazy_identity) =>
lazy_identity._lazy.Value;
}
readonly struct LazyCast<T, TSource> {
readonly Lazy<T> _lazy;
public LazyCast(TSource obj) {
_lazy = new Lazy<T>(impl);
T impl() =>
(T)(object)obj;
}
public T value => _lazy.Value;
public static implicit operator T(LazyCast<T, TSource> lazy_identity) =>
lazy_identity._lazy.Value;
}
}
+10
View File
@@ -33,6 +33,16 @@ namespace bts.utils {
public static IEnumerable<T> parse_rows<T>(string header_line, IEnumerable<string> rows, IReadOnlyDictionary<string, AssignColumnValue<T>> column_map, char delimiter) where T : new() =>
_parse_rows(header_line, rows.GetEnumerator(), column_map, delimiter);
public static IEnumerable<T> parse_rows<T>(IEnumerable<string> rows, IEnumerable<AssignColumnValue<T>> columns, char delimiter) where T : new() {
foreach (var r in rows) {
var cells = r.Split(delimiter);
var row = new T();
foreach (var (text, assign) in cells.Zip(columns))
assign(ref row, text);
yield return row;
}
}
// Assumes that the first row is column headers
public static IEnumerable<T> parse_rows_checked<T>(IEnumerable<string> rows, IReadOnlyDictionary<string, AssignColumnValue<T>> column_map, char delimiter) where T : new() {
var rows_en = rows.GetEnumerator();
@@ -0,0 +1,17 @@
using System.Diagnostics.Contracts;
namespace bts.utils {
static class StringExtensions {
[Pure]
public static string EmptyIfNull(this string str) =>
str ?? "";
[Pure]
public static string NullIfEmpty(this string str) =>
str == "" ? null : str;
[Pure]
public static bool IsNullOrEmpty(this string str) =>
string.IsNullOrEmpty(str);
}
}
@@ -0,0 +1,3 @@
Invalid Synth 1, 0.05, bad sec 1, 1, bad price mult 1, Q, SIM:ESM0, -1, 1, N
Invalid Synth 2, 0.10, bad sec 2, bad quantity 2, 0.9, H, SIM:YMM0, -2, 1.1, bad leg type
Invalid Synth 3, bad ticks 3, SIM:SIF1, bad quantity 3, bad price mult 3, Q, SIM:SIH1, -1, -1, N
1 Invalid Synth 1 0.05 bad sec 1 1 bad price mult 1 Q SIM:ESM0 -1 1 N
2 Invalid Synth 2 0.10 bad sec 2 bad quantity 2 0.9 H SIM:YMM0 -2 1.1 bad leg type
3 Invalid Synth 3 bad ticks 3 SIM:SIF1 bad quantity 3 bad price mult 3 Q SIM:SIH1 -1 -1 N
@@ -0,0 +1,2 @@
Valid Synth 1, 0.05, SIM:ESH0, 1, 2, H, SIM:ESM0, -1, 1, Q
Valid Synth 2, 0.10, SIM:YMH0, 3, 0.9, H, SIM:YMM0, -2, 1.1, Q
1 Valid Synth 1 0.05 SIM:ESH0 1 2 H SIM:ESM0 -1 1 Q
2 Valid Synth 2 0.10 SIM:YMH0 3 0.9 H SIM:YMM0 -2 1.1 Q
@@ -0,0 +1 @@
# Import Synthetics Test (10 min) ## Notes - The test refers to a couple [csv] files: - They are located in the 'docs\testing\import_synthetics' dir - If any security conflicts arise due to expired securities in the contract legs, please update the csv file with unexpired securities. - synthetics are displayed (in the main dialog) in the order in which they are listed in the csv file. - the security cells should be easy to identify, since every other cell, except for 'name,' is a number. - Direct concerns/complaints to John. *** 1. Open the Synthetic Management window (Launcher->Spreader->Synthetics). - Right click anywhere in the grid to open the context menu, then click "Import Synthetics..." to open the import dialog. - Select the 'valid_synths' file, then click 'Open.' - The 'Import Synthetics' dialog should appear with a synthetic row for each line in the file (should be 2). - Click OK to import/persist the synthetics. - Verify that the import succeeded: - A brief message dialog should appear saying something to the effect of "All synthetics were successfully imported." - The newly imported synthetics should be present in the Synthetic Management window. - Import the 'valid_synths' file again, this time the conflicts dialog should appear; it should say that '0/y synthetics have been successfully converted..' - There should be 1 conflict per line in the file for component 'Name' (because each name already exists). - Change the names to ones that don't already exist, then click continue to proceed to the main dialog. - No errors should be present in the main dialog (errors are indicated by a red exclamation point to the left of the expander arrow for a particular synthetic). - Click 'OK' to import/persist the synthetics. - Verify that the import succeeded. - A brief message dialog should appear saying something to the effect of "All synthetics were successfully imported." - The newly imported synthetics should be present in the Synthetic Management window. - Import the 'invalid_synths' file, the conflicts dialog should have the following errors (note the numbers at the end of the error text matches the line number of this error in the file): - Security: "bad sec 1," "bad sec 2" - Price Mult: "bad price mult 1" - Quantity: "bad quantity 2" - Tick Factors: "bad ticks 3" - Resolve each error with distinct values, take a screenshot of the conflicts dialog, then click 'Continue.' - Verify that the resolutions were applied to the correct rows (use the screenshot you just took as a reference). - Click 'OK' to import the persisted synthetics. - Verify that the import succeeded. - A brief message dialog should appear saying something to the effect of "All synthetics were successfully imported." - The newly imported synthetics should be present in the Synthetic Management window.