From 88932081b754440b1bfe5b67042592a5949edfea Mon Sep 17 00:00:00 2001 From: John Colvin Date: Wed, 23 Oct 2019 17:45:44 -0500 Subject: [PATCH 01/37] add WindowMaxSizeConverter to implement 'SizeToContent' max dimensions --- .../WindowSizeThresholdConverter.cs | 56 +++++++++++++++++++ 1 file changed, 56 insertions(+) create mode 100644 src/client/spark/view/Converters/WindowSizeThresholdConverter.cs diff --git a/src/client/spark/view/Converters/WindowSizeThresholdConverter.cs b/src/client/spark/view/Converters/WindowSizeThresholdConverter.cs new file mode 100644 index 000000000..fcd5eaece --- /dev/null +++ b/src/client/spark/view/Converters/WindowSizeThresholdConverter.cs @@ -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; + } +} \ No newline at end of file From 73cb56a6612b080bb1f4666d8e4f3d5ed87511b1 Mon Sep 17 00:00:00 2001 From: John Colvin Date: Wed, 20 Nov 2019 14:36:17 -0600 Subject: [PATCH 02/37] DIYGridRowPresenter - don't perform drag selection when SelectionMode=Single --- src/client/spark/view/Controls/DIYGrid/DIYGrid.cs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/client/spark/view/Controls/DIYGrid/DIYGrid.cs b/src/client/spark/view/Controls/DIYGrid/DIYGrid.cs index 1fa622608..bdfb6f7e9 100644 --- a/src/client/spark/view/Controls/DIYGrid/DIYGrid.cs +++ b/src/client/spark/view/Controls/DIYGrid/DIYGrid.cs @@ -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) { From 98caeb541078c9e3370481c8b9712a434febd23f Mon Sep 17 00:00:00 2001 From: John Colvin Date: Wed, 20 Nov 2019 14:46:53 -0600 Subject: [PATCH 03/37] MDDaemon - check that synthetic metadata.HasStrategy before adding to map --- src/client/spark/Daemons/MDDaemon.cs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/client/spark/Daemons/MDDaemon.cs b/src/client/spark/Daemons/MDDaemon.cs index b6bcfa70b..ea0bdfe9b 100644 --- a/src/client/spark/Daemons/MDDaemon.cs +++ b/src/client/spark/Daemons/MDDaemon.cs @@ -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(t.Where(kv => kv.Value.Deleted).Select(kv => kv.Key)); // add back 'undeleted' synthetics @@ -64,4 +64,4 @@ namespace bts { Task.Run(run); } } -} \ No newline at end of file +} From 2a72b03afc7e4a24c387bbb23eb998df5ff7c5f5 Mon Sep 17 00:00:00 2001 From: John Colvin Date: Wed, 20 Nov 2019 14:56:51 -0600 Subject: [PATCH 04/37] TickFactorsPicker - disable auto complete behavior --- .../spark/view/Controls/TickFactorsPicker/TickFactorsPicker.xaml | 1 + 1 file changed, 1 insertion(+) diff --git a/src/client/spark/view/Controls/TickFactorsPicker/TickFactorsPicker.xaml b/src/client/spark/view/Controls/TickFactorsPicker/TickFactorsPicker.xaml index 204ea5bb9..543a4863a 100644 --- a/src/client/spark/view/Controls/TickFactorsPicker/TickFactorsPicker.xaml +++ b/src/client/spark/view/Controls/TickFactorsPicker/TickFactorsPicker.xaml @@ -24,6 +24,7 @@ Date: Thu, 21 Nov 2019 17:49:45 -0600 Subject: [PATCH 05/37] ArrayHelper.trim was not actually reassigning ref with trimmed result --- src/client/spark_core/utils/ArrayUtils.cs | 1 + 1 file changed, 1 insertion(+) diff --git a/src/client/spark_core/utils/ArrayUtils.cs b/src/client/spark_core/utils/ArrayUtils.cs index cd0d0b42f..895096a59 100644 --- a/src/client/spark_core/utils/ArrayUtils.cs +++ b/src/client/spark_core/utils/ArrayUtils.cs @@ -8,6 +8,7 @@ namespace bts.utils { if (array.Length > size) { T[] trimmed = new T[size]; Array.Copy(array, trimmed, size); + array = trimmed; } } From d42f6b6fff6e370b36d64ff1e44a3b25bcc243d0 Mon Sep 17 00:00:00 2001 From: John Colvin Date: Thu, 21 Nov 2019 17:51:35 -0600 Subject: [PATCH 06/37] EnumHelper - generic add/remove_flags methods --- src/client/spark/view/Utility/EnumHelper.cs | 114 +++++++++++++++++++- 1 file changed, 112 insertions(+), 2 deletions(-) diff --git a/src/client/spark/view/Utility/EnumHelper.cs b/src/client/spark/view/Utility/EnumHelper.cs index 7829ce3e0..2dbf5b82a 100644 --- a/src/client/spark/view/Utility/EnumHelper.cs +++ b/src/client/spark/view/Utility/EnumHelper.cs @@ -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 value, T flags) where T : struct => + (T)EnumDescriptorStore.descriptor.add_flags(value, flags); + + public static T remove_flags(T value, T flags) where T : struct => + (T)EnumDescriptorStore.descriptor.remove_flags(value, flags); + public static T parse(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 has_flags; + public readonly Func add_flags, remove_flags; - public EnumDescriptor(Func has_flags) => + public EnumDescriptor( + Func has_flags, + Func add_flags, + Func 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 has_flags; + Func 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; + } } } } From 0937381a3f9db30775314a689d5cb49343c811f9 Mon Sep 17 00:00:00 2001 From: John Colvin Date: Thu, 21 Nov 2019 17:54:36 -0600 Subject: [PATCH 07/37] INotifyDataErrorInfo 'subscribe_has_errors' extension only notifies observers when HasErrors changes --- src/client/spark/core/Utility/ViewModelBase.cs | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/src/client/spark/core/Utility/ViewModelBase.cs b/src/client/spark/core/Utility/ViewModelBase.cs index 8fa702aaf..b4a7f6a75 100644 --- a/src/client/spark/core/Utility/ViewModelBase.cs +++ b/src/client/spark/core/Utility/ViewModelBase.cs @@ -41,12 +41,17 @@ namespace mbts.ui.shell { else vm.set_error(property, message); } - public static IObservable subscribe_has_errors(this INotifyDataErrorInfo vm) => + public static IObservable subscribe_has_errors(this INotifyDataErrorInfo vm, bool start_immediately = false) => Observable.Create(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 SubscribeValue(this IProperty property) => @@ -881,4 +886,4 @@ namespace mbts.ui.shell { return Disposable.Create(() => self.ErrorsChanged -= callback); } } -} \ No newline at end of file +} From 436dbd217c2683cc31b1bbd1861a271797a28f5d Mon Sep 17 00:00:00 2001 From: John Colvin Date: Wed, 20 Nov 2019 15:16:40 -0600 Subject: [PATCH 08/37] SP-266 synthetic csv parser/import dialog --- src/client/spark/Daemons/ErrorReporter.cs | 45 ++- src/client/spark/Images/Icons.cs | 7 +- src/client/spark/Images/Vector/Icons.xaml | 12 + .../Spreader/Import/ContractLegTypeView.xaml | 25 ++ .../Import/ContractLegTypeView.xaml.cs | 104 ++++++ .../SyntheticImportConflictsDialog.xaml | 47 +++ .../SyntheticImportConflictsDialog.xaml.cs | 11 + .../Import/SyntheticImportConflictsVM.cs | 101 ++++++ .../Import/SyntheticImportConflictsView.xaml | 199 ++++++++++++ .../SyntheticImportConflictsView.xaml.cs | 20 ++ .../Import/SyntheticImportDialog.xaml | 45 +++ .../Import/SyntheticImportDialog.xaml.cs | 11 + .../SyntheticImportRowCollectionView.cs | 236 ++++++++++++++ .../Spreader/Import/SyntheticImportVM.cs | 252 ++++++++++++++ .../Spreader/Import/SyntheticImportView.xaml | 270 +++++++++++++++ .../Import/SyntheticImportView.xaml.cs | 50 +++ .../Spreader/Import/SyntheticImporter.cs | 194 +++++++++++ .../Import/SyntheticSecurityParser.cs | 307 ++++++++++++++++++ .../spark/Modules/Spreader/SpreaderModel.cs | 59 +++- .../Spreader/SyntheticManagementWindow.cs | 18 +- .../Modules/Spreader/VM/SyntheticEditorVM.cs | 7 +- .../core/Collections/ObservableAutoWrapper.cs | 91 +++++- .../core/GlobalExtensions/DoubleHelper.cs | 9 +- .../core/GlobalExtensions/TickExtensions.cs | 15 + .../Buttons/ExpanderToggleButton.xaml | 10 +- .../Buttons/ExpanderToggleButton.xaml.cs | 10 +- .../Controls/TickUpDown/TickUpDownDouble.cs | 23 +- .../BooleanToVisibilityConverter.cs | 2 + .../view/Extensions/HighDpiExtensions.cs | 24 +- .../MarkupExtensions/DPIRoundedExtensions.cs | 13 + .../Numeric/DoubleExtension.cs | 14 +- .../view/Extensions/WPFAttachedBehavior.cs | 44 ++- src/client/spark/view/Spark/Core/TickUtils.cs | 3 + .../Spark/Utilities/SecurityDataHelper.cs | 16 + .../Utility/DataImport/ImportConflictsVM.cs | 107 ++++++ .../spark/view/Utility/SelectableItemVM.cs | 39 ++- src/client/spark/view/Utility/WPFHelper.cs | 7 + .../spark/view/Utility/WindowUtilities.cs | 65 +++- .../spark_api/utils/AnonymousDisposable.cs | 37 +++ .../Extensions/EnumerableExtensions.cs | 7 + src/client/spark_core/utils/ArrayUtils.cs | 43 +++ src/client/spark_core/utils/LazyCast.cs | 47 +++ src/client/spark_core/utils/RowParser.cs | 10 + .../spark_core/utils/StringExtensions.cs | 17 + 44 files changed, 2622 insertions(+), 51 deletions(-) create mode 100644 src/client/spark/Modules/Spreader/Import/ContractLegTypeView.xaml create mode 100644 src/client/spark/Modules/Spreader/Import/ContractLegTypeView.xaml.cs create mode 100644 src/client/spark/Modules/Spreader/Import/SyntheticImportConflictsDialog.xaml create mode 100644 src/client/spark/Modules/Spreader/Import/SyntheticImportConflictsDialog.xaml.cs create mode 100644 src/client/spark/Modules/Spreader/Import/SyntheticImportConflictsVM.cs create mode 100644 src/client/spark/Modules/Spreader/Import/SyntheticImportConflictsView.xaml create mode 100644 src/client/spark/Modules/Spreader/Import/SyntheticImportConflictsView.xaml.cs create mode 100644 src/client/spark/Modules/Spreader/Import/SyntheticImportDialog.xaml create mode 100644 src/client/spark/Modules/Spreader/Import/SyntheticImportDialog.xaml.cs create mode 100644 src/client/spark/Modules/Spreader/Import/SyntheticImportRowCollectionView.cs create mode 100644 src/client/spark/Modules/Spreader/Import/SyntheticImportVM.cs create mode 100644 src/client/spark/Modules/Spreader/Import/SyntheticImportView.xaml create mode 100644 src/client/spark/Modules/Spreader/Import/SyntheticImportView.xaml.cs create mode 100644 src/client/spark/Modules/Spreader/Import/SyntheticImporter.cs create mode 100644 src/client/spark/Modules/Spreader/Import/SyntheticSecurityParser.cs create mode 100644 src/client/spark/view/Extensions/MarkupExtensions/DPIRoundedExtensions.cs create mode 100644 src/client/spark/view/Utility/DataImport/ImportConflictsVM.cs create mode 100644 src/client/spark_core/utils/LazyCast.cs create mode 100644 src/client/spark_core/utils/StringExtensions.cs diff --git a/src/client/spark/Daemons/ErrorReporter.cs b/src/client/spark/Daemons/ErrorReporter.cs index e2a7b462b..f14d9e76b 100644 --- a/src/client/spark/Daemons/ErrorReporter.cs +++ b/src/client/spark/Daemons/ErrorReporter.cs @@ -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( + this ErrorReporter error_reporter, + IEnumerable> execute, + Func result_selector, + string desc, + string title) { + // + try { + var results = await Task.WhenAll(execute as Task[] ?? 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); + } } -} \ No newline at end of file +} diff --git a/src/client/spark/Images/Icons.cs b/src/client/spark/Images/Icons.cs index aef0d6142..4223bde21 100644 --- a/src/client/spark/Images/Icons.cs +++ b/src/client/spark/Images/Icons.cs @@ -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"); } } diff --git a/src/client/spark/Images/Vector/Icons.xaml b/src/client/spark/Images/Vector/Icons.xaml index 650c43eb0..3b4f882f6 100644 --- a/src/client/spark/Images/Vector/Icons.xaml +++ b/src/client/spark/Images/Vector/Icons.xaml @@ -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 + + 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.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 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/client/spark/Modules/Spreader/Import/SyntheticImportConflictsView.xaml.cs b/src/client/spark/Modules/Spreader/Import/SyntheticImportConflictsView.xaml.cs new file mode 100644 index 000000000..0d2bbd6d9 --- /dev/null +++ b/src/client/spark/Modules/Spreader/Import/SyntheticImportConflictsView.xaml.cs @@ -0,0 +1,20 @@ +using System.Windows.Controls; + +namespace bts.shell.spreader { + enum SyntheticContractComponent { + Name, + TickSize, + Security, + PriceMultiplier, + Quantity, + LegType + } + + /// + /// Interaction logic for SyntheticImportConflictsView.xaml + /// + partial class SyntheticImportConflictsView : UserControl { + public SyntheticImportConflictsView() => + InitializeComponent(); + } +} diff --git a/src/client/spark/Modules/Spreader/Import/SyntheticImportDialog.xaml b/src/client/spark/Modules/Spreader/Import/SyntheticImportDialog.xaml new file mode 100644 index 000000000..b904ca775 --- /dev/null +++ b/src/client/spark/Modules/Spreader/Import/SyntheticImportDialog.xaml @@ -0,0 +1,45 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/client/spark/Modules/Spreader/Import/SyntheticImportDialog.xaml.cs b/src/client/spark/Modules/Spreader/Import/SyntheticImportDialog.xaml.cs new file mode 100644 index 000000000..917de1574 --- /dev/null +++ b/src/client/spark/Modules/Spreader/Import/SyntheticImportDialog.xaml.cs @@ -0,0 +1,11 @@ +using System.Windows; + +namespace bts.shell.spreader { + /// + /// Interaction logic for SyntheticImportDialog.xaml + /// + partial class SyntheticImportDialog : Window { + public SyntheticImportDialog() => + InitializeComponent(); + } +} diff --git a/src/client/spark/Modules/Spreader/Import/SyntheticImportRowCollectionView.cs b/src/client/spark/Modules/Spreader/Import/SyntheticImportRowCollectionView.cs new file mode 100644 index 000000000..6b1b7813f --- /dev/null +++ b/src/client/spark/Modules/Spreader/Import/SyntheticImportRowCollectionView.cs @@ -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 _base_groups, _groups_wrapper; + ObservableAutoWrapper _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 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(_base_groups, obj => new SyntheticImportRowCollectionViewGroup((CollectionViewGroup)obj, this)); + _groups_wrapper = new ReadOnlyObservableCollection(_groups); + } + return _groups_wrapper; + } + } + + public void set_all_expanded(bool is_expanded) { + foreach (var g in Groups.OfTypeSafe()) + g.set_all_expanded(is_expanded); + } + } + + class SyntheticImportRowCollectionViewGroup : CollectionViewGroup, INotifyDataErrorInfo, IRaiseNotifyPropertyChanged, IEquatable { + static readonly string _desc_delim = ", "; + readonly SyntheticImportRowCollectionView _root; + readonly CollectionViewGroup _from; + readonly Dictionary _inner_groups = new Dictionary(); + readonly Dictionary _rows = new Dictionary(); + 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 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().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().Select(l => l.price_multiplier))); + // quantity desc + public string quantity_desc => + _quantity_desc ?? (_quantity_desc = string.Join(_desc_delim, ProtectedItems.OfType().Select(l => l.quantity))); + // security desc + public string security_desc => + _security_desc ?? (_security_desc = string.Join(_desc_delim, ProtectedItems.OfType().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().Any(l => l.HasErrors); + public IEnumerable GetErrors(string propertyName) => + propertyName == nameof(Items) ? + Items.OfType().SelectMany(l => l.AllErrors) : + Enumerable.Empty(); + + public void set_all_expanded(bool is_expanded) { + this.is_expanded = is_expanded; + foreach (var g in Items.OfTypeSafe()) + 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(ref T backing, T new_value, [CallerMemberName]string prop = "") => + _set(ref backing, new_value, EqualityComparer.Default, prop); + + void _set(ref T backing, T new_value, IEqualityComparer 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; + } + } + } +} diff --git a/src/client/spark/Modules/Spreader/Import/SyntheticImportVM.cs b/src/client/spark/Modules/Spreader/Import/SyntheticImportVM.cs new file mode 100644 index 000000000..5847f1557 --- /dev/null +++ b/src/client/spark/Modules/Spreader/Import/SyntheticImportVM.cs @@ -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 _security_map = DictionaryHelper.empty(); + + 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 rows { get; } = new ObservableCollection(); + public ObservableCollection flat_legs { get; } = new ObservableCollection(); + public IReadOnlyDictionary 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 { + readonly ReactiveThresholdMonitor _leg_errors_mon = new ReactiveThresholdMonitor(l => l.subscribe_has_errors(true)); + readonly Func _get_name_exists; + SecurityImmutable? _security; + ExecutionStrategyImmutable? _strategy; + TickFactors _tick_factors; + string _name; + bool _is_selected; + + public SyntheticImportRowVM(uint user_id, Func get_name_exists) { + this.user_id = user_id; + _get_name_exists = get_name_exists; + _validate(); + add_leg_cmd = new DelegateCommand(r => { + if (r != null) { + r.legs.Add(new ContractLegVM { + price_multiplier = 1, + quantity = 1, + owner = r + }); + } + }); + remove_leg_cmd = new DelegateCommand(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 legs { get; } = new ObservableCollection(); + 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 { + 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; + } +} diff --git a/src/client/spark/Modules/Spreader/Import/SyntheticImportView.xaml b/src/client/spark/Modules/Spreader/Import/SyntheticImportView.xaml new file mode 100644 index 000000000..9c7cfe5c9 --- /dev/null +++ b/src/client/spark/Modules/Spreader/Import/SyntheticImportView.xaml @@ -0,0 +1,270 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/client/spark/Modules/Spreader/Import/SyntheticImportView.xaml.cs b/src/client/spark/Modules/Spreader/Import/SyntheticImportView.xaml.cs new file mode 100644 index 000000000..39bc9f8ab --- /dev/null +++ b/src/client/spark/Modules/Spreader/Import/SyntheticImportView.xaml.cs @@ -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 + } + + /// + /// Interaction logic for SyntheticImportView.xaml + /// + 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 { + 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(); + } + } +} diff --git a/src/client/spark/Modules/Spreader/Import/SyntheticImporter.cs b/src/client/spark/Modules/Spreader/Import/SyntheticImporter.cs new file mode 100644 index 000000000..0b8b2c802 --- /dev/null +++ b/src/client/spark/Modules/Spreader/Import/SyntheticImporter.cs @@ -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.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 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(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 parsed_synths, IEnumerable 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)) { + Parallel.ForEach( + new_ids.Where(r => r.key.HasValue), + r => bus.post(SparkTags.SyntheticDeleteTag, 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); + } + } + } + } +} diff --git a/src/client/spark/Modules/Spreader/Import/SyntheticSecurityParser.cs b/src/client/spark/Modules/Spreader/Import/SyntheticSecurityParser.cs new file mode 100644 index 000000000..2002d7774 --- /dev/null +++ b/src/client/spark/Modules/Spreader/Import/SyntheticSecurityParser.cs @@ -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 _legs_valid_mon = + new ReactiveThresholdMonitor(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 legs { get; } = new ObservableCollection(); + + 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(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 subscribe_is_valid() => + Observable.Create(o => { + o.OnNext(is_valid); + invalidated += on_invalidated; + return Disposable.Create(() => invalidated -= on_invalidated); + void on_invalidated() => + o.OnNext(is_valid); + }); + + void _set(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 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(val) ?? 0.0; + case SyntheticContractComponent.PriceMultiplier: return (sec, leg, leg_params, val) => leg.PriceMultiplier = ConvertUtils.try_convert(val) ?? double.NaN; + case SyntheticContractComponent.Quantity: return (sec, leg, leg_params, val) => leg.Quantity = ConvertUtils.try_convert(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 , regardless of whether or not that component has any conflicts. + public static Dictionary>> get_conflicts(IEnumerable parsed_fills) { + var missing_components = EnumHelper.get_values().ToDictionary(c => c, c => new Dictionary>()); + var mk_list = new Func>(_ => 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>> get_conflicts(IEnumerable import_rows) { + var missing_components = EnumHelper.get_values().ToDictionary(c => c, c => new Dictionary>()); + var mk_list = new Func>(_ => 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 parse_rows(IEnumerable rows, IReadOnlyDictionary security_map, ISet 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> 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 reverse_lookup(IReadOnlyDictionary 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 name(Func 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 contract_security(Func 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, 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; + } + } + } +} diff --git a/src/client/spark/Modules/Spreader/SpreaderModel.cs b/src/client/spark/Modules/Spreader/SpreaderModel.cs index 916e7f078..4c4e330f4 100644 --- a/src/client/spark/Modules/Spreader/SpreaderModel.cs +++ b/src/client/spark/Modules/Spreader/SpreaderModel.cs @@ -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, Result?)>(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 sec, Result? strat)> impl() { + var result = await _service.create_synthetic_async(sec); + Result? 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 create_synthetic(SecurityImmutable synthetic) { if (synthetic.ContractCase != Security.ContractOneofCase.Synthetic) return null; @@ -112,4 +169,4 @@ namespace mbts.spark { return success && !result.Values.Any(st => st.md.security.Synthetic.Name.Trim().ToLower() == name); } } -} \ No newline at end of file +} diff --git a/src/client/spark/Modules/Spreader/SyntheticManagementWindow.cs b/src/client/spark/Modules/Spreader/SyntheticManagementWindow.cs index cfbe2b7e3..52c33465f 100644 --- a/src/client/spark/Modules/Spreader/SyntheticManagementWindow.cs +++ b/src/client/spark/Modules/Spreader/SyntheticManagementWindow.cs @@ -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, 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 _vm = new SingleValuePump(); StartupData _state; OrdersModel _orders_model; @@ -27,7 +31,6 @@ namespace mbts.spark { IReadOnlyList _commands; readonly IWindowSettingsManager _settings_manager; - public SyntheticManagementWindow(SyntheticManagementWindowFactory factory, IBus bus, OrdersModel orders_model, StartupData state, IWindowSettingsManager 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( @@ -112,6 +119,9 @@ namespace mbts.spark { _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); } } -} \ No newline at end of file +} diff --git a/src/client/spark/Modules/Spreader/VM/SyntheticEditorVM.cs b/src/client/spark/Modules/Spreader/VM/SyntheticEditorVM.cs index b9c676d9e..881705dab 100644 --- a/src/client/spark/Modules/Spreader/VM/SyntheticEditorVM.cs +++ b/src/client/spark/Modules/Spreader/VM/SyntheticEditorVM.cs @@ -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())) { diff --git a/src/client/spark/core/Collections/ObservableAutoWrapper.cs b/src/client/spark/core/Collections/ObservableAutoWrapper.cs index 203bc3697..375c99e01 100644 --- a/src/client/spark/core/Collections/ObservableAutoWrapper.cs +++ b/src/client/spark/core/Collections/ObservableAutoWrapper.cs @@ -28,6 +28,9 @@ namespace mbts.ui.utility { public static IReadOnlyObservableCollection SelectObservable(this ObservableCollection source, Func selector) => new SelectorWrapper(source, source, selector); + public static IObservableCollection SelectObservable(this ObservableCollection source, Func selector, Func reverse_selector) => + new SelectorWrapper(source, source, selector, reverse_selector); + public static IDisposable connect_sorted(ObservableCollection source, ObservableCollection target, IComparer 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 : IReadOnlyObservableCollection { - readonly IReadOnlyList _source_list; + class SelectorWrapper : IObservableCollection, IReadOnlyObservableCollection, IList { + readonly IList _source_list; readonly Func _selector; + readonly Func _reverse_selector; - public SelectorWrapper(IReadOnlyList source_list, INotifyCollectionChanged source_notifier, Func selector) { + public SelectorWrapper(IList source_list, INotifyCollectionChanged source_notifier, Func selector, Func 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 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.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); + } } } diff --git a/src/client/spark/core/GlobalExtensions/DoubleHelper.cs b/src/client/spark/core/GlobalExtensions/DoubleHelper.cs index 4b9292936..f4473b794 100644 --- a/src/client/spark/core/GlobalExtensions/DoubleHelper.cs +++ b/src/client/spark/core/GlobalExtensions/DoubleHelper.cs @@ -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; } -} \ No newline at end of file +} diff --git a/src/client/spark/core/GlobalExtensions/TickExtensions.cs b/src/client/spark/core/GlobalExtensions/TickExtensions.cs index 467cb394c..3dc1c0a80 100644 --- a/src/client/spark/core/GlobalExtensions/TickExtensions.cs +++ b/src/client/spark/core/GlobalExtensions/TickExtensions.cs @@ -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; diff --git a/src/client/spark/view/Controls/Buttons/ExpanderToggleButton.xaml b/src/client/spark/view/Controls/Buttons/ExpanderToggleButton.xaml index ab3ca8131..87c7d16c6 100644 --- a/src/client/spark/view/Controls/Buttons/ExpanderToggleButton.xaml +++ b/src/client/spark/view/Controls/Buttons/ExpanderToggleButton.xaml @@ -9,13 +9,18 @@ + + + - + @@ -356,13 +404,39 @@