diff --git a/.gitignore b/.gitignore index 7c976336d..10a357f8b 100644 --- a/.gitignore +++ b/.gitignore @@ -1,34 +1,36 @@ -nohup.out -build/ -cmake-build-debug/ -.idea/ -.dir-locals.el -*.pyc -.vscode/* -!.vscode/*.json -.vs -obj/ -*.csproj.user -*.vspx -*.psess -msbuild.log -*.orig -vcxproj.user -src/client/spark/Properties/launchSettings.json -compile_commands.json -.cquery_cached_index/ -src/client/sparkcmd/Properties/launchSettings.json -node_modules -paket-files -project.lock.json -src/server/sparkd/orderman/perf_analysis/data -src/server/sparkd/orderman/perf_analysis/logs/ -src/server/sparkd/orderman/perf_analysis/trace_data/ -.fake -*.fsx.lock -*.code-workspace -src/lib/orderman/perf_analysis/logs/latency_data/ -trace_data/ -/src/lib/orderman/perf_analysis/last_pretty_log.csv -/src/lib/orderman/perf_analysis/log.csv -/doc/user/public/* +nohup.out +build/ +cmake-build-debug/ +.idea/ +.dir-locals.el +*.pyc +.vscode/* +!.vscode/*.json +.vs +obj/ +*.csproj.user +*.vspx +*.psess +msbuild.log +*.orig +vcxproj.user +src/client/spark/Properties/launchSettings.json +compile_commands.json +.cquery_cached_index/ +src/client/sparkcmd/Properties/launchSettings.json +node_modules +paket-files +project.lock.json +src/server/sparkd/orderman/perf_analysis/data +src/server/sparkd/orderman/perf_analysis/logs/ +src/server/sparkd/orderman/perf_analysis/trace_data/ +.fake +*.fsx.lock +*.code-workspace +src/lib/orderman/perf_analysis/logs/latency_data/ +trace_data/ +/src/lib/orderman/perf_analysis/last_pretty_log.csv +/src/lib/orderman/perf_analysis/log.csv +/doc/user/public/* +.ionide/* +src/web/ui/.ionide/symbolCache.db diff --git a/.vscode/launch.json b/.vscode/launch.json index 20ffefdc1..99ab46efc 100644 --- a/.vscode/launch.json +++ b/.vscode/launch.json @@ -118,7 +118,7 @@ "program": "${workspaceRoot}/build/Debug/bin/net471/sparkcmd.exe", "args": [ "test", - "test_filter" + "ApiUpdateTests" ], "cwd": "${workspaceRoot}", "stopAtEntry": false, @@ -249,7 +249,7 @@ "program": "/home/bts/spark/build/ninja_debug/server/sparkd", "args": [ "test", - "SingleWriterConcurrentVector" + "[algo]" ], "stopAtEntry": false, "cwd": "/home/bts/spark/build/ninja_debug/server/", diff --git a/doc/user/content/bts_spark/Algos/_index.md b/doc/user/content/bts_spark/Algos/_index.md deleted file mode 100644 index f3955e979..000000000 --- a/doc/user/content/bts_spark/Algos/_index.md +++ /dev/null @@ -1,46 +0,0 @@ -+++ -title = "BTS Basic Algos" -weight = 10 -sort_by = "weight" -insert_anchor_links = "right" -+++ - - -## Lean - -The goal of the lean order is to watch the opposite-inside market size and cross when that size goes below the threshold (this also implies a cross if that size goes to zero and the market trades away from you) If the market trades toward you, you can opt into several different behaviors - -##### Parameters - * Cross Thresh - size thresh in absolute or ratio terms - * Max Chase Ticks - max levels to pay up, in ticks - - -## Join -The goal of the join order is to watch the opposite-inside market and join when the market flips (that is, when the best offer becomes the best bid) and has at least threshold size. - -##### Parameters - * Join Thresh - size thresh in absolute or ratio terms - - -## Top - -The goal of the top order is to not trade by yourself, but the intent at the time of order entry is to get filled.If the order is on the market (say current bid price) AND the quantity on that bid price is below top thresh then cancel the order else remain working. - -##### Parameters - * Top Thresh - size thresh in absolute or ratio terms - - -## Cover -A Cover order’s purpose is to fire a hedge order (of any type) in response to fills from it’s child order on the opposite side of the market N ticks away - -##### Parameters - * Profit Ticks - ticks above or below fill price to place profit / cover order - - -## OCO -An OCO order creates a relationship between a child order and a 'stop' or 'other' order such that when one of these is cancelled, both cancel, or when one is filled, the other order's size is debited in the amount of the fill. - -Composing this order with Cover simulates scalping functionality - -##### Parameters - * Stop Ticks - ticks below or above main order to place stop / other order \ No newline at end of file diff --git a/doc/user/content/bts_spark/Glossary/index.md b/doc/user/content/bts_spark/Glossary/_index.md similarity index 100% rename from doc/user/content/bts_spark/Glossary/index.md rename to doc/user/content/bts_spark/Glossary/_index.md diff --git a/doc/user/content/bts_spark/Help/index.md b/doc/user/content/bts_spark/Help/_index.md similarity index 100% rename from doc/user/content/bts_spark/Help/index.md rename to doc/user/content/bts_spark/Help/_index.md diff --git a/doc/user/content/bts_spark/Launcher/index.md b/doc/user/content/bts_spark/Launcher/_index.md similarity index 100% rename from doc/user/content/bts_spark/Launcher/index.md rename to doc/user/content/bts_spark/Launcher/_index.md diff --git a/doc/user/content/bts_spark/Logging-In-to-the-System/index.md b/doc/user/content/bts_spark/Logging-In-to-the-System/_index.md similarity index 100% rename from doc/user/content/bts_spark/Logging-In-to-the-System/index.md rename to doc/user/content/bts_spark/Logging-In-to-the-System/_index.md diff --git a/doc/user/content/bts_spark/Market/index.md b/doc/user/content/bts_spark/Market/_index.md similarity index 100% rename from doc/user/content/bts_spark/Market/index.md rename to doc/user/content/bts_spark/Market/_index.md diff --git a/doc/user/content/bts_spark/My-Windows/index.md b/doc/user/content/bts_spark/My-Windows/_index.md similarity index 100% rename from doc/user/content/bts_spark/My-Windows/index.md rename to doc/user/content/bts_spark/My-Windows/_index.md diff --git a/doc/user/content/bts_spark/Settings/index.md b/doc/user/content/bts_spark/Settings/_index.md similarity index 100% rename from doc/user/content/bts_spark/Settings/index.md rename to doc/user/content/bts_spark/Settings/_index.md diff --git a/doc/user/content/bts_spark/Spreader/index.md b/doc/user/content/bts_spark/Spreader/_index.md similarity index 100% rename from doc/user/content/bts_spark/Spreader/index.md rename to doc/user/content/bts_spark/Spreader/_index.md diff --git a/doc/user/content/bts_spark/Trading/OrderTypes/index.md b/doc/user/content/bts_spark/Trading/OrderTypes/index.md new file mode 100644 index 000000000..d045a8cf7 --- /dev/null +++ b/doc/user/content/bts_spark/Trading/OrderTypes/index.md @@ -0,0 +1,77 @@ ++++ +title = "Basic Algos" +weight = 1 +sort_by = "weight" +insert_anchor_links = "right" +aliases = ["./bts_spark/Algos/"] ++++ + +## Lean + +The goal of the lean order is to watch the opposite-inside market size and cross when that size goes below the threshold (this also implies a cross if that size goes to zero and the market trades away from you) If the market trades toward you, you can opt into several different behaviors + +##### Parameters + * Cross Thresh - size thresh in absolute or ratio terms + * Max Chase Ticks - max levels to pay up, in ticks + + +## Join +The goal of the join order is to watch the opposite-inside market and join when the market flips (that is, when the best offer becomes the best bid) and has at least threshold size. + +##### Parameters + * Join Thresh - size thresh in absolute or ratio terms + + +## Top + +The goal of the top order is to not trade by yourself, but the intent at the time of order entry is to get filled.If the order is on the market (say current bid price) AND the quantity on that bid price is below top thresh then cancel the order else remain working. + +##### Parameters + * Top Thresh - size thresh in absolute or ratio terms + + +## Cover +A Cover order’s purpose is to fire a hedge order (of any type) in response to fills from it’s child order on the opposite side of the market N ticks away + +##### Parameters + * Profit Ticks - ticks above or below fill price to place profit / cover order + + +## OCO +An OCO order creates a relationship between a child order and a 'stop' or 'other' order such that when one of these is cancelled, both cancel, or when one is filled, the other order's size is debited in the amount of the fill. + +Composing this order with Cover simulates scalping functionality + +##### Parameters + * Stop Ticks - ticks below or above main order to place stop / other order + +## Splitter +The splitter is useful for pro-rata markets where you want to vary your exposure independent of the order quantity that you want to fill. The splitter will complete when the number of fills reaches or exceeds the order quantity but it will put exposed_qty total size on the market. Splitter favors order size over queue position. + +If exposed_qty is set to 0 the splitter will continue to exist in the Order Book but will cancel all of its child orders. This makes it a useful building block for custom algos that need to implement a 'paused' state. + +##### Parameters + * exposed_qty - The total quantity to expose on the market. + * max_order_qty - The maximum size of a single order. + + +## Scratch +The scratch algo is similar to Lean, but instead of watching the opposite inside market, it watches the same side market and pays up when this quantity recedes below the scratch_threshold + +##### Parameters + * scratch_threshold - The quantity on the same side market below which to scratch + * chase_ticks - The number of ticks through the opposite market to pay up + + +## ProRata +The prorata algo is a special case hedging algo for pro-rata markets. Users can specify two hedge types-- normal hedge and overfill hedge, the latter is spawned when you receive more fills than your fill_limit. Further, the algo attempts to scratch when in an overfilled state AND optionally the same side size falls below stay_in_threshold + +##### Parameters + * hedge_ticks - The amount of ticks better hedges are placed on the opposite side market as the fill + * chase_ticks - How many ticks through the opposite market on a scratch + * fill_limit - The limit after which the algo considers further fills to be 'overfills' + * stay_in_threshold - A same side size threshold that enables the algo to 'stay in' even if overfilled + * enable_scratch_on_overfill - When true, overfills are immediately scratched upon the algo exiting + * enable_stay_in - When true, the algo will 'stay in' so long as the same side size is above stay_in_threshold, when false the algo attempts to 'get out' (and potentially scratch overfills) as soon as it reaches overfill status + * hedge - Child order type to send for normal hedges + * overfill_hedge - Child order type to send for overfill hedges diff --git a/doc/user/content/bts_spark/Trading/index.md b/doc/user/content/bts_spark/Trading/_index.md similarity index 100% rename from doc/user/content/bts_spark/Trading/index.md rename to doc/user/content/bts_spark/Trading/_index.md diff --git a/doc/user/content/release_notes/_index.md b/doc/user/content/release_notes/_index.md index f2ba4c36e..323f05d0f 100644 --- a/doc/user/content/release_notes/_index.md +++ b/doc/user/content/release_notes/_index.md @@ -4,6 +4,75 @@ weight = 3 sort_by = "weight" insert_anchor_links = "right" +++ +## 2.8.0 +### User Visible Changes + - Added ProRata and Scratch algos + - Ladder badge now grows/shrinks to fill the containing cell + - Attached algo parameters are now displayed in the update panel + - Fixed a bug where the update panel would show '-' values when only + 1 order was selected + - Fixed a bug that cause cause a failure on startup if the user + loaded a workspace with a Ladder that had a dynamic order type + selected by default +### Internal changes + - Made it easier to generate simple UI's for new order types +### API Changes + - Dynamic orders can now use QuantityMeasure parameter types + +## 2.7.2 +### User Visible Changes + - Changed the login dialog to avoid leaking workspace names from other users. + - Added new Splitter algo. From the manual: The splitter is useful + for pro-rata markets where you want to vary your exposure + independent of the order quantity that you want to fill. The + splitter will complete when the number of fills reaches or exceeds + the order quantity but it will put exposed_qty total size on the + market. Splitter favors order size over queue position. +### Internal Changes + - Made spark more resilient to lack of connectivity to the CME web site for downloading of templates. + +## 2.7.1 +### User Visible Changes + - Fixed some issues with the Cover algo, where in some circumstances + it would erroneously cancel launched hedges on completion. + +## 2.7.0 +### User Visible Changes + - Allowed algos to process "in-flight" fills while shutting down + - Changed the cover algo to continue to hedge while shutting down +### API Changes + - Changed the API so that algos do not fully terminate until all + their children are terminated. Algos that are in the process of + shutting down in response to a complete or cancel call will still + receive child updates, which they can use to calculate and report + an accurate fill count (during this shutdown stage algos cannot + create, cancel or update children). A new IAlgoServices method, + is_shutting_down(), can be used to determine if an algo is + shutting down. + +## 2.6.2 +### User Visible Changes + - Fixed an issue in the ladder where in some cases the mini order book could not be brought up from a badge + - Fixed a rare race condition that could lead to erroneous limit enforcement + - Fixed an issue with the margin limits where an error could occur if an account name with more than 12 chars was used + +## 2.6.1 +### User Visible Changes + - Fixed an issue in the ladder where an error could occur when trying to change ladder settings for the first time + +## 2.6.0 +### User Visible Changes + - In the ladder made last trade more distinctive when overlayed on the volumn column + - In the ladder, corrected display of volume tool tip + - In the ladder, changed the consolidation of last trade to consider only the price ignoring aggressor changes + - Added an option for the Top Algo to delete itself if within N ticks from top of book + - Address a rare issue that could lead to an error report on UI exit + - Added margin risk limits + - Added the "Offset" algo. Offset prices a child algo at a parameterizable distance from the top of the book + - Avoided switching the current account and order type on open ladders when limits are changed +### Internal Changes + - Ensure that admin logins are always allowed to login, regardless of keycode status. + ## 2.5.0 ### User Visible Changes - Added loss limit risk check @@ -170,7 +239,7 @@ insert_anchor_links = "right" - Integrated stunnel into UI to make VPN setup unnecessary in unsecured environments. ## 1.5.7 ### User Visible Changes - - New videos have been added to the manual describing the [Algo Studio](./bts_spark/Trading/index.md#algo-studio) and [Spreader](./bts_spark/Spreader/index.md) + - New videos have been added to the manual describing the [Algo Studio](./bts_spark/Trading/_index.md#algo-studio) and [Spreader](./bts_spark/Spreader/_index.md) - Fixed a bug that occasionally would cause windows to be position outside the visible screen on startup - Fixed a bug in the order book form that would occasionally cause the Recreate Order option to be unavailable - Added a confirmation step to Cancel All, Cancel Buys and Cancel Sells commands @@ -293,7 +362,7 @@ insert_anchor_links = "right" - The zoom slider can be enabled from Ladder Form -> Settings button -> Left Pane tab -> check Zoom Slider checkbox - The zoom functionality can also be performed via hotkey and mouse wheel combinations - Zoom In = CTRL + Mouse wheel up - - Zoom Out = CTRL + Mouse wheel down + - Zoom Out = CTRL + Mouse wheel down - Reset zoom = CTRL + Mouse wheel click or double click on the zoom slider ### Exchange simulator - Improved the exchange simulator to track real market data more closely @@ -398,7 +467,8 @@ insert_anchor_links = "right" - This is configurable from a ladder's settings as well ### Customized settings in all windows - All windows now contain a settings page where grid settings (font color, size, etc) are applied - - These settings can be saved on a per-window basis or as a Default for newly-launched windows + - These settings can be saved on a per-window basis or as a Default for newly-launched windows + ## 1.3.1 Through 1.3.4 diff --git a/src/client/spark/Daemons/ShellServices.cs b/src/client/spark/Daemons/ShellServices.cs index bcfd91e6e..eb8c4ed65 100644 --- a/src/client/spark/Daemons/ShellServices.cs +++ b/src/client/spark/Daemons/ShellServices.cs @@ -2,6 +2,7 @@ using bts.api.core; using bts.api.md.auxiliary; using bts.api.orderman; +using bts.api.orderman.algo; using bts.api.persistence; using bts.api.position; using bts.api.synthetic; @@ -45,41 +46,11 @@ namespace Spark { [Export] public MarketDataRelay md_replay => context.locate(); - //[Export] - //public AlgoService algo_service => context.locate(); - AlgoServiceWrapper _algo_service_wrapper; [Export] - public AlgoServiceWrapper algo_service_wrapper => _algo_service_wrapper ?? (_algo_service_wrapper = new AlgoServiceWrapper(context)); + public AlgoDefinitionService algo_definition_service => context.locate(); [Export] public MBOService mbo_service => context.locate(); } - - class AlgoServiceWrapper { - public enum Mode { - None, - Hierarchical, - Flat - } - - public AlgoServiceWrapper(ServiceContext context) { - var flat_model_options = mbts.config.Configuration.get(); - if (flat_model_options.enabled) { - flat = context.locate(); - } else { - hierarhical = context.locate(); - } - } - - public AlgoService hierarhical { get; } - public bts.api.orderman.algo.AlgoDefinitionService flat { get; } - public Mode mode { - get { - if (hierarhical != null) return Mode.Hierarchical; - if (flat != null) return Mode.Flat; - return Mode.None; - } - } - } } diff --git a/src/client/spark/Modules/Trading/AlgoStudio/AlgoPersistenceHelper.cs b/src/client/spark/Modules/Trading/AlgoStudio/AlgoPersistenceHelper.cs deleted file mode 100644 index 2660bc149..000000000 --- a/src/client/spark/Modules/Trading/AlgoStudio/AlgoPersistenceHelper.cs +++ /dev/null @@ -1,112 +0,0 @@ -using bts.api.core; -using bts.collections; -using mbts.collections; -using System.Collections.Generic; -using System.Collections.ObjectModel; -using System.Threading.Tasks; - -namespace mbts.spark { - /// - /// This class's primary purpose is to handle async AlgoService persistence calls for the AlgoStudioVM/OrderPropertiesEditorVM. - /// When a new definition/template item is persisted for the first time, it's corresponding viewmodel (, ) - /// must be removed and replaced with a new one that has the brand new persisted id (). As part of its duty, this class makes sure that the new persisted items are inserted into the same index as their unpersisted predecessor. - /// - static class AlgoPersistenceHelper { - public static (int? def_index, int? tmp_index) selection_snapshot(IList definitions, AlgoDefinitionVM selected_definition, AlgoDefinitionTemplateVM selected_template) { - var def = selected_definition; - var tmp = selected_template; - int? def_index = def == null ? (int?)null : definitions.IndexOf(def); - int? tmp_index = tmp == null ? (int?)null : tmp.owner.templates.IndexOf(tmp); - return (def_index, tmp_index); - } - - public static async Task> persist_definition(OrdersModel model, IList definitions, AlgoDefinitionVM definition) { - int def_index = definitions.IndexOf(definition); - return await persist(model, definitions.WrapSubRange(def_index, 1).WrapSelector(def => (def, definition.templates.AsList()), t => t.def)); - } - - public static async Task> persist_template(OrdersModel model, IList definitions, AlgoDefinitionTemplateVM template) { - switch (template.owner.key.mode) { - case AlgoKey.Mode.Unpersisted: return await persist_definition(model, definitions, template.owner); - case AlgoKey.Mode.Persisted: - int def_index = definitions.IndexOf(template.owner); - int tmp_index = template.owner.templates.IndexOf(template); - return await persist(model, definitions.WrapSubRange(def_index, 1).WrapSelector(def => (def, def.templates.WrapSubRange(tmp_index, 1)), t => t.def)); - default: return DictionaryHelper.empty(); - } - } - - public static async Task> persist_all(OrdersModel model, ObservableKeyedCollection definitions) => - await persist(model, definitions.WrapSelector(def => (def, def.templates.AsList()), t => t.def)); - - /// - /// Persists each pair of definition/templates, then returns a map of non-persisted keys to persisted ones (, , ). - /// The key-map gives callers the ability to replace unpersisted items with persisted ones before the next update arrives. - /// Note: use a to suspend updates while awaiting this task; don't resume them until all unpersisted items have been replaced. - /// caters to this pre-emptive adding behavior, in it's callback, it checks if added items are already present, and if so, treats them as changes instead. - /// PS: the reason for all this madness is so newly persisted items are inserted in the same index as their placeholder counterpart. The only way to connect the non-persisted keys with their persisted counterparts - /// is to await each save-op individually, and build a map with the results..hence the returned key-map. - /// - /// - /// - /// An AlgoKey->AlgoKey map of old placeholder ids to newly persisted ones. - public static async Task> persist(OrdersModel model, IList<(AlgoDefinitionVM definition, IList templates)> definition_templates) { - var placeholder_to_persisted_keys = new Dictionary(); - for (int i = 0; i < definition_templates.Count; i++) { - (var def, var templates) = definition_templates[i]; - var persisted_def = def; - if (def.is_dirty) { - var def_record = await model.algo_model.save_definition(def.create_algo_def()); - if (def_record.HasValue) { - switch (def.key.mode) { - case AlgoKey.Mode.Factory: - case AlgoKey.Mode.Unpersisted: - persisted_def = def.to_persisted(def_record.Value); - foreach (var tmp in templates) { - AlgoDefinitionTemplateVM persisted_tmp; - var tmp_record = await model.algo_model.save_template(tmp.create(def_record.Value)); - if (tmp_record.HasValue) { - persisted_def.templates.Add(persisted_tmp = tmp.to_persisted(persisted_def, new AlgoData(tmp_record.Value.value, tmp_record.Value.name, tmp_record.Value.key))); - } else { - /// If the save-op fails, the unpersisted template is cloned and added to the persisted def's template items, so the user may try to save it again without having to re-enter all the templated-values. - /// Q: "why don't we just re-add the same template to the persisted def, the save-op failed, so nothing changed...why do we need a new one?" - /// A: "A new template vm must be created because its owner has changed (it's a readonly prop, )." - persisted_def.templates.Add(persisted_tmp = new AlgoDefinitionTemplateVM(persisted_def, model, tmp.create_def_data())); - } - placeholder_to_persisted_keys[tmp.key] = persisted_tmp.key; - } - persisted_def.connect(); - if (def.key.mode == AlgoKey.Mode.Unpersisted) { - definition_templates[i] = (persisted_def, persisted_def.templates); - } else { - definition_templates.Add((persisted_def, persisted_def.templates)); - } - placeholder_to_persisted_keys[def.key] = persisted_def.key; - break; - } - } - } else { - // so the def isn't dirty, but it still might have dirty templates - using (persisted_def.buffer_updates()) { - for (int j = 0; j < templates.Count; j++) { - var tmp = templates[j]; - if (!tmp.is_dirty) - continue; - var tmp_record = await model.algo_model.save_template(tmp.create()); - if (tmp_record.HasValue) { - switch (tmp.key.mode) { - case AlgoKey.Mode.Unpersisted: - var persisted_tmp = tmp.to_persisted(persisted_def, new AlgoData(tmp_record.Value.value, tmp_record.Value.name, tmp_record.Value.key)); - templates[j] = persisted_tmp; - placeholder_to_persisted_keys[tmp.key] = persisted_tmp.key; - break; - } - } - } - } - } - } - return placeholder_to_persisted_keys; - } - } -} \ No newline at end of file diff --git a/src/client/spark/Modules/Trading/AlgoStudio/AlgoStudioView.xaml b/src/client/spark/Modules/Trading/AlgoStudio/AlgoStudioView.xaml index bd8136fad..07fbecf35 100644 --- a/src/client/spark/Modules/Trading/AlgoStudio/AlgoStudioView.xaml +++ b/src/client/spark/Modules/Trading/AlgoStudio/AlgoStudioView.xaml @@ -12,14 +12,11 @@ xmlns:uag="clr-namespace:mbts.ui.spark.algo" xmlns:uspcv="clr-namespace:mbts.ui.spark.converters" xmlns:sys="clr-namespace:System;assembly=mscorlib" - u:StateManager.VisualState="{Binding content_source.algo_root, Converter={x:Static usp:AlgoStudioView.EditPaneVisualStateConverter}}" + u:StateManager.VisualState="{Binding selected_definition.algo_root, Converter={x:Static usp:AlgoStudioView.EditPaneVisualStateConverter}}" Background="{StaticResource CommonBackground}" > - - - 4 8 @@ -33,9 +30,6 @@ - - - AbbreviationActive AbbreviationInactive @@ -130,70 +124,8 @@ - - @@ -221,94 +153,26 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + - - - - - - - + - - + + @@ -430,7 +294,7 @@ Margin="{StaticResource Margin.LP1}" HorizontalAlignment="Stretch" VerticalAlignment="Center" - Text="{Binding content_source.name, UpdateSourceTrigger=PropertyChanged, Delay=25}" + Text="{Binding selected_definition.name, UpdateSourceTrigger=PropertyChanged, Delay=25}" /> @@ -452,7 +316,7 @@ Abbrev. - + @@ -478,8 +342,8 @@ Hint: the default color is that of the algo-root ( ). @@ -496,7 +360,7 @@ x:Name="default_badge" Grid.Column="1" Margin="{StaticResource Margin.LP1}" - Fill="{Binding content_source.algo_root.meta.Color, Converter={StaticResource ColorToBrushConverter}}" + Fill="{Binding selected_definition.algo_root.meta.Color, Converter={StaticResource ColorToBrushConverter}}" Style="{StaticResource RectangleBadgeStyle}" /> @@ -506,7 +370,7 @@ VerticalAlignment="Center" VerticalContentAlignment="Center" Margin="{StaticResource Margin.LP2}" - IsChecked="{Binding content_source.custom_badge_color.enabled}" + IsChecked="{Binding selected_definition.custom_badge_color.enabled}" GroupName="Badge" > @@ -526,7 +390,7 @@ Grid.Row="1" Grid.Column="1" Margin="3,0" - Fill="{Binding content_source.custom_badge_color.value, Converter={StaticResource ColorToBrushConverter}}" + Fill="{Binding selected_definition.custom_badge_color.value, Converter={StaticResource ColorToBrushConverter}}" Style="{StaticResource RectangleBadgeStyle}" /> to open the color picker popup. @@ -541,7 +405,7 @@ - @@ -580,4 +444,4 @@ - \ No newline at end of file + diff --git a/src/client/spark/Modules/Trading/AlgoStudio/AlgoStudioView.xaml.cs b/src/client/spark/Modules/Trading/AlgoStudio/AlgoStudioView.xaml.cs index 95214f635..f142e44a4 100644 --- a/src/client/spark/Modules/Trading/AlgoStudio/AlgoStudioView.xaml.cs +++ b/src/client/spark/Modules/Trading/AlgoStudio/AlgoStudioView.xaml.cs @@ -1,43 +1,24 @@ using mbts.spark; +using mbts.ui.controls; using mbts.ui.converters; -using System; +using mbts.ui.extensions; using System.Windows.Controls; using System.Windows.Data; using System.Windows.Input; namespace mbts.ui.spark { partial class AlgoStudioView : UserControl { - public const string BadgesInTreeViewVisibilityKey = nameof(BadgesInTreeViewVisibilityKey); public static readonly IValueConverter EditPaneVisualStateConverter = ValueConverter.create(obj => obj == null ? VisualStates.Inactive : VisualStates.Active); - IAlgoStudioViewController _controller; - public AlgoStudioView() { InitializeComponent(); - DataContextChanged += (s, e) => set_controller(); - set_controller(); - // local methods - void set_controller() => Disposable.replace(ref _controller, AlgoStudioViewControllerFactory.create(DataContext, _tree_view, name_text_box, custom_badge_color_picker_button, custom_badge_color_picker_popup)); + PopupViewController.attach(custom_badge_color_picker_popup, custom_badge_color_picker_button); + this.ConnectDataContext(vm => vm.request_view_focus_name += focus_name, vm => vm.request_view_focus_name -= focus_name); + void focus_name(AlgoDefinitionVM target) => + Dispatcher.InvokeAsync(() => Keyboard.Focus(name_text_box)); } - public new AlgoStudioVM DataContext { - get => base.DataContext as AlgoStudioVM; - set => base.DataContext = value; - } - - public void add_definition() => _controller.add_definition(); - public void add_definition_clone(AlgoDefinitionVM src_definition) => _controller.add_definition_clone(src_definition); - public void add_template(AlgoDefinitionVM definition) => _controller.add_template(definition); - public void rename_definition(AlgoDefinitionVM definition) => _controller.rename_definition(definition); - public void rename_template(AlgoDefinitionTemplateVM template) => _controller.rename_template(template); - public void select_definition(AlgoDefinitionVM definition) => _controller.select_definition(definition); - public void select_template(AlgoDefinitionTemplateVM template) => _controller.select_template(template); - public IDisposable preserve_selected_definition() => _controller.preserve_selected_definition(); - - void _end_edit_executed(object s, ExecutedRoutedEventArgs e) => - _controller.end_edit(e); - public static class VisualStateNames { public static class EditPane { public const string GroupName = nameof(EditPane); @@ -75,14 +56,6 @@ namespace mbts.ui.spark { Inactive = $"{GroupName}{VisualStates.Inactive}"; } - public static class TreeViewBadge { - public const string GroupName = nameof(TreeViewBadge); - - public static readonly string - Active = $"{GroupName}{VisualStates.Active}", - Inactive = $"{GroupName}{VisualStates.Inactive}"; - } - public static class FavoriteToggleButton { public const string GroupName = nameof(FavoriteToggleButton); diff --git a/src/client/spark/Modules/Trading/AlgoStudio/AlgoStudioViewController.cs b/src/client/spark/Modules/Trading/AlgoStudio/AlgoStudioViewController.cs deleted file mode 100644 index dbdbd1f7b..000000000 --- a/src/client/spark/Modules/Trading/AlgoStudio/AlgoStudioViewController.cs +++ /dev/null @@ -1,133 +0,0 @@ -using mbts.spark; -using mbts.ui.controls; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Windows.Controls; -using System.Windows.Controls.Primitives; -using System.Windows.Input; - -namespace mbts.ui.spark { - interface IAlgoStudioViewController : IDisposable { - void add_definition(); - void add_definition_clone(AlgoDefinitionVM src_definition); - void add_template(AlgoDefinitionVM definition); - void rename_definition(AlgoDefinitionVM definition); - void rename_template(AlgoDefinitionTemplateVM template); - void end_edit(ExecutedRoutedEventArgs e); - void select_definition(AlgoDefinitionVM definition); - void select_template(AlgoDefinitionTemplateVM template); - IDisposable preserve_selected_definition(); - } - - class AlgoStudioViewControllerFactory { - static readonly IAlgoStudioViewController _empty = new EmptyController(); - - public static IAlgoStudioViewController create(AlgoStudioVM vm, TreeView tree_view, TextBox name_text_box, Button color_picker_button, Popup color_picker_popup) => - vm == null || tree_view == null || name_text_box == null || color_picker_button == null || color_picker_popup == null ? - _empty : new Controller(vm, tree_view, name_text_box, color_picker_button, color_picker_popup); - - /// - /// This wrapper class is returned by when the vm or tree_view is null. - /// This further separates the view from the controller-logic; it doesn't even need to check for null when accessing methods. - /// - class EmptyController : IAlgoStudioViewController { - public void add_definition() { } - public void add_definition_clone(AlgoDefinitionVM src_definition) { } - public void add_template(AlgoDefinitionVM definition) { } - public void rename_definition(AlgoDefinitionVM definition) { } - public void rename_template(AlgoDefinitionTemplateVM template) { } - public void end_edit(ExecutedRoutedEventArgs e) { } - public void select_definition(AlgoDefinitionVM definition) { } - public void select_template(AlgoDefinitionTemplateVM template) { } - public IDisposable preserve_selected_definition() => Disposable.empty; - public void Dispose() { } - } - - class Controller : IAlgoStudioViewController { - readonly AlgoStudioVM _vm; - readonly TreeView _tree_view; - readonly TextBox _name_text_box; - IDisposable _dispose; - - public Controller(AlgoStudioVM vm, TreeView tree_view, TextBox name_text_box, Button color_picker_button, Popup color_picker_popup) { - _vm = vm; - _tree_view = tree_view; - _name_text_box = name_text_box; - _dispose = PopupViewController.attach(color_picker_popup, color_picker_button); - } - - public void add_definition() { - _vm.add_new_definition(); - _begin_edit(); - } - - public void add_definition_clone(AlgoDefinitionVM src_definition) { - _vm.add_new_definition_clone(src_definition); - _begin_edit(); - } - - public void add_template(AlgoDefinitionVM def) { - var new_tmp = def.template_factory(); - def.templates.Add(new_tmp); - _begin_edit(); - } - - public void end_edit(ExecutedRoutedEventArgs e) { - if (e.OriginalSource is EditableTextBlock etb) { - etb.end_edit(); - _get_container(etb.DataContext)?.SetCurrentValue(TreeViewItem.IsSelectedProperty, true); - } - } - - public void rename_definition(AlgoDefinitionVM definition) { - if (_tree_view.ItemContainerGenerator.ContainerFromItem(definition) is TreeViewItem tvi) { - var etb = tvi.descendants_of_type().FirstOrDefault(); - etb.SetCurrentValue(EditableTextBlock.IsEditingProperty, true); - } - } - - public void rename_template(AlgoDefinitionTemplateVM template) { - if (_tree_view.ItemContainerGenerator.ContainerFromItem(template.owner) is TreeViewItem tvi) { - if (tvi.ItemContainerGenerator.ContainerFromItem(template) is TreeViewItem ttvi) { - var etb = ttvi.descendants_of_type().FirstOrDefault(); - etb.SetCurrentValue(EditableTextBlock.IsEditingProperty, true); - } - } - } - - public void select_definition(AlgoDefinitionVM definition) => - _tree_view.ItemContainerGenerator.ContainerFromItem(definition)?.SetCurrentValue(TreeViewItem.IsSelectedProperty, true); - - public void select_template(AlgoDefinitionTemplateVM template) { - if (_tree_view.ItemContainerGenerator.ContainerFromItem(template.owner) is TreeViewItem def_view) { - def_view.SetCurrentValue(TreeViewItem.IsSelectedProperty, true); - def_view.ItemContainerGenerator.ContainerFromItem(template)?.SetCurrentValue(TreeViewItem.IsSelectedProperty, true); - } - } - - public IDisposable preserve_selected_definition() => - Disposable.Create(() => { - var name = _vm.selected_definition.name; - if (_vm.definitions.TryGetFirst(d => d.name == name, out AlgoDefinitionVM def)) - _tree_view.ItemContainerGenerator.ContainerFromItem(def)?.SetCurrentValue(TreeViewItem.IsSelectedProperty, true); - }); - - public void Dispose() => - Disposable.dispose(ref _dispose); - - void _begin_edit() => - WPFHelper.push_frame_until(() => Keyboard.Focus(_name_text_box) == _name_text_box); - - TreeViewItem _get_container(object obj) => - obj is AlgoDefinitionTemplateVM t ? _get_container(t) : - obj is AlgoDefinitionVM d ? _get_container(d) : null; - - TreeViewItem _get_container(AlgoDefinitionVM d) => - _tree_view.ItemContainerGenerator.ContainerFromItem(d) as TreeViewItem; - - TreeViewItem _get_container(AlgoDefinitionTemplateVM t) => - _get_container(t.owner) is TreeViewItem dview ? dview.ItemContainerGenerator.ContainerFromItem(t) as TreeViewItem : null; - } - } -} \ No newline at end of file diff --git a/src/client/spark/Modules/Trading/AlgoStudio/AlgoStudioWindow.cs b/src/client/spark/Modules/Trading/AlgoStudio/AlgoStudioWindow.cs index 24164b38f..5d2b975e4 100644 --- a/src/client/spark/Modules/Trading/AlgoStudio/AlgoStudioWindow.cs +++ b/src/client/spark/Modules/Trading/AlgoStudio/AlgoStudioWindow.cs @@ -62,35 +62,19 @@ namespace mbts.spark { _vm = new AlgoStudioVM(_model); _vm.load_from(_state); _view = new AlgoStudioView { DataContext = _vm }; - _view.Resources[AlgoStudioView.BadgesInTreeViewVisibilityKey] = _ui_configuration.show_badges_in_tree_view ? Visibility.Visible : Visibility.Collapsed; _resources = new CompositeDisposable(); - // observable sources - var content_src = _vm.observe_selected().Select(_ => _vm.content_source); // add definition - _commands.Add(new SparkCommandCommand("Add Algo", Icons.AddBoxes, new DelegateCommand(_view.add_definition))); - // add definition clone - var add_definition_clone_spark_cmd = new ObservantSparkCommandCommand(Icons.DocumentCopy, d => $"Clone '{d?.name}'", d => d != null, _view.add_definition_clone); - _commands.Add(add_definition_clone_spark_cmd); - // add template - var add_template_spark_cmd = new ObservantSparkCommandCommand(Icons.AddFile, d => $"Add '{d?.name}' Template", d => d != null, _view.add_template) { - show_in_toolbar = (_ui_configuration.add_template_button & bts.config.AlgoStudioOptions.AddTemplateButton.MainToolBar) == bts.config.AlgoStudioOptions.AddTemplateButton.MainToolBar, - show_in_context_menu = (_ui_configuration.add_template_button & bts.config.AlgoStudioOptions.AddTemplateButton.DefinitionContextMenu) == bts.config.AlgoStudioOptions.AddTemplateButton.DefinitionContextMenu - }; - _commands.Add(add_template_spark_cmd); - _resources.Add(_vm.subscribe_definition().OnDispatcher().Subscribe(add_definition_clone_spark_cmd, add_template_spark_cmd)); + _commands.Add(new SparkCommandCommand("Add Algo", Icons.AddBoxes, _vm.add_definition_cmd)); + // clone definition + var clone_selected_definition_spark_cmd = new SparkCommandCommand(string.Empty, Icons.DocumentCopy, _vm.clone_selected_definition_cmd); + _commands.Add(clone_selected_definition_spark_cmd); + _resources.Add(_vm.subscribe_definition().OnDispatcher().Subscribe( + def => clone_selected_definition_spark_cmd.title = def == null ? $"Clone (None Selected)" : $"Clone '{def.name}'")); // save if (_ui_configuration.can_save_specific) { - var content_is_dirty_src = _vm.observe_selected().SelectManyInSeries(t => { - if (t.template != null) { - return t.template.observe_is_dirty(); - } else if (t.definition != null) { - return t.definition.subscribe_is_definition_dirty(); - } else return Observable.Return(false); - }); - _commands.Add(new ReactiveSparkCommand(content_src.OnDispatcher().Select(c => $"Save '{c?.name}'"), Icons.DiskFile, () => { - if (_vm.selected_template is AlgoDefinitionTemplateVM t) - _vm.save_template(t).ignore(); - else if (_vm.selected_definition is AlgoDefinitionVM d) + var content_is_dirty_src = _vm.subscribe_definition().SelectManyInSeries(def => def?.subscribe_is_definition_dirty() ?? Observable.Return(false)); + _commands.Add(new ReactiveSparkCommand(_vm.subscribe_definition().OnDispatcher().Select(c => $"Save '{c?.name}'"), Icons.DiskFile, () => { + if (_vm.selected_definition is AlgoDefinitionVM d) _vm.save_definition(d).ignore(); }, content_is_dirty_src)); } @@ -101,48 +85,39 @@ namespace mbts.spark { // undo/redo if (_ui_configuration.can_undo_redo) { // undo - var undo_cmd = new ObservantCommand(() => _vm.content_source?.try_undo()); + var undo_cmd = new ObservantCommand(() => _vm.selected_definition?.try_undo()); var undo_spark_cmd = new SparkCommandCommand("Undo", Icons.UndoCircular, undo_cmd); - var can_undo_source = _vm.observe_selected().SelectManyInSeries(tup => { - IAlgoStudioContentVM content = (IAlgoStudioContentVM)tup.template ?? tup.definition; - return content != null ? + var can_undo_source = _vm.subscribe_definition().SelectManyInSeries(def => + def != null ? Observable.Create(o => { - content.can_undo_changed += notify; + def.can_undo_changed += notify; notify(); - return Disposable.Create(() => content.can_undo_changed -= notify); - void notify() => o.OnNext(content.can_undo); + return Disposable.Create(() => def.can_undo_changed -= notify); + void notify() => o.OnNext(def.can_undo); }) : - Observable.Return(false); - }); + Observable.Return(false)); _commands.Add(undo_spark_cmd); _resources.Add(can_undo_source.Subscribe(undo_cmd)); // redo - var redo_cmd = new ObservantCommand(() => _vm.content_source?.try_redo()); + var redo_cmd = new ObservantCommand(() => _vm.selected_definition?.try_redo()); var redo_spark_cmd = new SparkCommandCommand("Redo", Icons.RedoCircular, redo_cmd); - var can_redo_source = _vm.observe_selected().SelectManyInSeries(tup => { - IAlgoStudioContentVM content = (IAlgoStudioContentVM)tup.template ?? tup.definition; - return content != null ? + var can_redo_source = _vm.subscribe_definition().SelectManyInSeries(def => + def != null ? Observable.Create(o => { - content.can_redo_changed += notify; + def.can_redo_changed += notify; notify(); - return Disposable.Create(() => content.can_redo_changed -= notify); - void notify() => o.OnNext(content.can_redo); + return Disposable.Create(() => def.can_redo_changed -= notify); + void notify() => o.OnNext(def.can_redo); }) : - Observable.Return(false); - }); + Observable.Return(false)); _commands.Add(redo_spark_cmd); _resources.Add(can_redo_source.Subscribe(redo_cmd)); } // remove var remove_spark_cmd = new ObservantSparkCommandCommand(Icons.Trash, v => $"Remove '{v?.name}'", v => v != null, value => { - if (value is AlgoDefinitionTemplateVM t) { - _vm.remove_template(t).ignore(); - } else if (value is AlgoDefinitionVM d) { + if (value is AlgoDefinitionVM d) { string prompt; MessageBoxImage icon; - if (_model.algo_model.templates_enabled() && d.templates.Count > 0) { - prompt = $"Deleting this definition ({d.name}) will also delete its templates ({d.templates.Count}).\n\nDo you wan to Continue?"; - icon = MessageBoxImage.Warning; - } else if (d.key.mode == AlgoKey.Mode.Persisted) { + if (d.key.mode == AlgoKey.Mode.Persisted) { prompt = $"Are you sure you want to delete '{d.name}?'"; icon = MessageBoxImage.Question; } else { @@ -162,7 +137,7 @@ namespace mbts.spark { } }); _commands.Add(remove_spark_cmd); - _resources.Add(content_src.OnDispatcher().Subscribe(remove_spark_cmd)); + _resources.Add(_vm.subscribe_definition().OnDispatcher().Subscribe(remove_spark_cmd)); } void _dispose_core() { diff --git a/src/client/spark/Modules/Trading/AlgoStudio/Model/AlgoData.cs b/src/client/spark/Modules/Trading/AlgoStudio/Model/AlgoData.cs index 3acd47fcc..acb014317 100644 --- a/src/client/spark/Modules/Trading/AlgoStudio/Model/AlgoData.cs +++ b/src/client/spark/Modules/Trading/AlgoStudio/Model/AlgoData.cs @@ -1,31 +1,57 @@ using bts.api.orderman; +using bts.api.orderman.algo; using bts.utils; using mbts.spark.utilities; using System; using System.Windows.Media; namespace mbts.spark { + // This is a core data type on the front end, so data validation is strict, as bad values may yield weird/difficult to track bugs. + // Descriptive factory methods are favored over public constructors, as they are less likely to be misused. struct AlgoData : IEquatable { public readonly CustomOrderDefinitionImmutable value; public readonly string name; public readonly AlgoKey key; - public AlgoData(CustomOrderDefinitionImmutable value) - : this(value, value.display_name(), OrderDataHelper.get_shallow_factory_key(value)) { } - - public AlgoData(CustomOrderDefinitionImmutable value, string name, AlgoKey key) { + AlgoData(CustomOrderDefinitionImmutable value, string name, AlgoKey key) { this.value = value; this.name = name; this.key = key; } - public AlgoData with(CustomOrderDefinitionImmutable? value = null, string name = null) => - new AlgoData(value ?? this.value, name ?? this.name, key); + /// + /// This is the only factory method that allows callers to explicitly specify a name. + /// It should only be used within the context of creating, or renaming, studio algos. + /// + public static AlgoData create(CustomOrderDefinitionImmutable def, string name, AlgoKey key) => + new AlgoData(def, name, key); + + /// + /// Reconstructs from a , with a special caveat in the case of : + /// a fallback/default name is used instead of the composite algo's true name, which must be obtained from the stream. + /// + public static AlgoData from_custom_def(CustomOrderDefinitionImmutable def) { + switch (def.CustomCase) { + case CustomOrderDefinition.CustomOneofCase.Composite: + string name = $"({OrderDataHelper.abbreviate_algo_type(def.CustomCase)}){OrderDataHelper.abbreviate_algo_type(def.Composite.Definition.CustomCase)}"; + return new AlgoData(def.Composite.Definition, name, AlgoKey.from_composite_key(def.Composite.AlgoTemplateKey)); + case CustomOrderDefinition.CustomOneofCase.Dynamic: + return new AlgoData(def,def.Dynamic.DynamicOrderType, AlgoKey.from_dynamic_type(def.Dynamic.DynamicOrderType)); + default: + return new AlgoData(def, def.CustomCase.display_name(), AlgoKey.from_known_type(def.CustomCase)); + } + } + + public static AlgoData from_record(AlgoDefinitionRecordImmutable record) => + new AlgoData(record.Algo.Definition, record.Algo.Name, AlgoKey.from_composite_key(record.Key)); + + public static AlgoData create_unpersisted(CustomOrderDefinitionImmutable custom_def, string name) => + new AlgoData(custom_def, name, AlgoKey.create_unpersisted()); public bool Equals(AlgoData other) => key == other.key && name == other.name && - OrderDataHelper.EqualsHelpers.custom_order_def_compareri.Equals(value, other.value); + OrderDataHelper.EqualsHelpers.custom_order_defi_comparer.Equals(value, other.value); public override bool Equals(object obj) => EqualityComparer.equals_obj(this, obj); public override int GetHashCode() => diff --git a/src/client/spark/Modules/Trading/AlgoStudio/Model/AlgoKey.cs b/src/client/spark/Modules/Trading/AlgoStudio/Model/AlgoKey.cs index c1056508f..82f955ee6 100644 --- a/src/client/spark/Modules/Trading/AlgoStudio/Model/AlgoKey.cs +++ b/src/client/spark/Modules/Trading/AlgoStudio/Model/AlgoKey.cs @@ -1,12 +1,13 @@ using bts.api.orderman; -using bts.persist.algo; using bts.utils; -using mbts.ui.utility; +using mbts.utils; using ProtoBuf; using System; using System.Linq; namespace mbts.spark { + // This is a core data type on the front end, so data validation is strict, as bad values may yield weird/difficult to track bugs. + // Descriptive factory methods are favored over public constructors, as they are less likely to be misused. [ProtoContract] struct AlgoID : IEquatable { [ProtoMember(1)] @@ -47,24 +48,23 @@ namespace mbts.spark { } } - public static AlgoID from_algo_key(AlgoKey key, IMaskIndexInt32 dynamic_type_index) { + public static AlgoID from_algo_key(AlgoKey key) { switch (key.mode) { - case AlgoKey.Mode.Factory: - return AlgoStructureSerializer.to_algo_id(key.factory.structure, dynamic_type_index); - case AlgoKey.Mode.Persisted: - return new AlgoID(key.persisted.id_uint); + case AlgoKey.Mode.Factory: return new AlgoID(key.factory); + case AlgoKey.Mode.Dynamic: return new AlgoID(key.dynamic_type); + case AlgoKey.Mode.Persisted: return new AlgoID(key.persisted); + default: throw ExceptionBuilder.Argument.unexpected_case(key.mode, nameof(key)); } - return new AlgoID(CustomOrderDefinition.CustomOneofCase.None); } - public static AlgoKey to_algo_key(AlgoID id, IMaskIndexInt32 dynamic_type_index) { + public static AlgoKey to_algo_key(AlgoID id) { if (id._factory_key.HasValue) - return new AlgoKey(id._factory_key.Value); + return AlgoKey.from_known_type(id._factory_key.Value); if (id._persisted_key.HasValue) - return new AlgoKey(new AlgoPersistedKey(id._persisted_key.Value)); + return AlgoKey.from_composite_key(id._persisted_key.Value); if (id._dynamic_key != null) - return new AlgoKey(new AlgoNameStructureKey(id._dynamic_key, AlgoStructureSerializer.structure_key(dynamic_type_index.to_int(id._dynamic_key)))); - return default; + return AlgoKey.from_dynamic_type(id._dynamic_key); + throw new ArgumentException("ID is empty.", nameof(id)); } public bool Equals(AlgoID other) => @@ -85,55 +85,93 @@ namespace mbts.spark { public static bool operator !=(AlgoID a, AlgoID b) => !a.Equals(b); } - /// TODO: Remove , and redirect references to . struct AlgoKey : IEquatable { - readonly AlgoPersistedKey? _persisted_key; - readonly AlgoNameStructureKey? _factory_key; + readonly uint? _composite_key; readonly Guid? _unpersisted; + readonly string _dynamic_type; + readonly CustomOrderDefinition.CustomOneofCase? _factory_type; - public AlgoKey(Guid id_guid) { - _persisted_key = null; - _factory_key = null; + AlgoKey(Guid id_guid) { + _composite_key = null; _unpersisted = id_guid; + _dynamic_type = null; + _factory_type = null; } - public AlgoKey(CustomOrderDefinition.CustomOneofCase factory_root_algo_type) - : this(new AlgoNameStructureKey(factory_root_algo_type)) { } - - public AlgoKey(AlgoNameStructureKey factory_key) { - _persisted_key = null; - _factory_key = factory_key; + public AlgoKey(uint composite_key) { + _composite_key = composite_key; _unpersisted = null; + _dynamic_type = null; + _factory_type = null; } - public AlgoKey(AlgoPersistedKey persisted_key) { - _persisted_key = persisted_key; - _factory_key = null; + public AlgoKey(string dynamic_type) { + _composite_key = null; _unpersisted = null; + _dynamic_type = dynamic_type; + _factory_type = null; + } + + public AlgoKey(CustomOrderDefinition.CustomOneofCase factory_type) { + _composite_key = null; + _unpersisted = null; + _dynamic_type = null; + _factory_type = factory_type; } public enum Mode { None, Persisted, Unpersisted, + Dynamic, Factory } public bool is_persisted => mode == Mode.Persisted; - public AlgoPersistedKey persisted => _persisted_key.Value; - public AlgoNameStructureKey factory => _factory_key ?? new AlgoNameStructureKey(CustomOrderDefinition.CustomOneofCase.None); + public uint persisted => _composite_key.Value; public Guid unpersisted => _unpersisted.Value; + public CustomOrderDefinition.CustomOneofCase factory => _factory_type.Value; + public string dynamic_type => _dynamic_type; public Mode mode { get { - if (_persisted_key.HasValue) return Mode.Persisted; + if (_factory_type.HasValue) return Mode.Factory; + if (_composite_key.HasValue) return Mode.Persisted; + if (_dynamic_type != null) return Mode.Dynamic; if (_unpersisted.HasValue) return Mode.Unpersisted; - if (_factory_key.HasValue) return Mode.Factory; return Mode.None; } } + public static AlgoKey create_unpersisted() => + new AlgoKey(Guid.NewGuid()); + + public static AlgoKey from_custom_def(CustomOrderDefinitionImmutable custom_def) { + switch (custom_def.CustomCase) { + case CustomOrderDefinition.CustomOneofCase.Dynamic: return new AlgoKey(custom_def.Dynamic.DynamicOrderType); + case CustomOrderDefinition.CustomOneofCase.Composite: return new AlgoKey(custom_def.Composite.AlgoTemplateKey); + default: return new AlgoKey(custom_def.CustomCase); + } + } + + public static AlgoKey from_known_type(CustomOrderDefinition.CustomOneofCase known_type) { + if (known_type == CustomOrderDefinition.CustomOneofCase.Dynamic) + throw new ArgumentException(nameof(known_type), "Potential loss of data: no dynamic type name specified."); + if (known_type == CustomOrderDefinition.CustomOneofCase.Composite) + throw new ArgumentException(nameof(known_type), "Potential loss of data: no composite id specified."); + return new AlgoKey(known_type); + } + + public static AlgoKey from_dynamic_type(string dynamic_type) { + if (string.IsNullOrEmpty(dynamic_type)) + throw ExceptionBuilder.Argument.null_or_empty(nameof(dynamic_type)); + return new AlgoKey(dynamic_type); + } + + public static AlgoKey from_composite_key(uint composite_key) => + new AlgoKey(composite_key); + public bool Equals(AlgoKey other) { Mode m = mode; if (m == other.mode) { @@ -141,6 +179,7 @@ namespace mbts.spark { case Mode.Persisted: return persisted == other.persisted; case Mode.Unpersisted: return unpersisted == other.unpersisted; case Mode.Factory: return factory == other.factory; + case Mode.Dynamic: return dynamic_type == other.dynamic_type; case Mode.None: return true; } } @@ -155,6 +194,7 @@ namespace mbts.spark { case Mode.Persisted: hash = persisted.GetHashCode(); phase_mult = 2; break; case Mode.Unpersisted: hash = unpersisted.GetHashCode(); phase_mult = 4; break; case Mode.Factory: hash = factory.GetHashCode(); phase_mult = 3; break; + case Mode.Dynamic: hash = dynamic_type.GetHashCode(); phase_mult = 5; break; default: return 0; } return EqualityComparer.phase_hash(hash, phase_mult); @@ -165,4 +205,4 @@ namespace mbts.spark { InvalidOperationException _unexpected_mode_ex() => new InvalidOperationException($"Unexpected Mode '{mode}.'"); } -} +} \ No newline at end of file diff --git a/src/client/spark/Modules/Trading/AlgoStudio/Model/AlgoPersistedKey.cs b/src/client/spark/Modules/Trading/AlgoStudio/Model/AlgoPersistedKey.cs index 37eeba1c5..7ac07e2bf 100644 --- a/src/client/spark/Modules/Trading/AlgoStudio/Model/AlgoPersistedKey.cs +++ b/src/client/spark/Modules/Trading/AlgoStudio/Model/AlgoPersistedKey.cs @@ -40,7 +40,7 @@ namespace bts.persist.algo { public bool is_persisted => mode != Mode.None; public mbts.spark.AlgoKey to_algo_key() => - new mbts.spark.AlgoKey(this); + new mbts.spark.AlgoKey(_id_uint ?? 0); public bool Equals(AlgoPersistedKey other) { Mode m = mode; diff --git a/src/client/spark/Modules/Trading/AlgoStudio/Model/AlgoStructureKey.cs b/src/client/spark/Modules/Trading/AlgoStudio/Model/AlgoStructureKey.cs deleted file mode 100644 index 5b4bd573f..000000000 --- a/src/client/spark/Modules/Trading/AlgoStudio/Model/AlgoStructureKey.cs +++ /dev/null @@ -1,177 +0,0 @@ -using bts.api.orderman; -using bts.utils; -using mbts.spark.utilities; -using mbts.ui.utility; -using System; -using System.Collections.Generic; -using System.Linq; - -namespace mbts.spark { - struct AlgoNameStructureKey : IEquatable { - public readonly string name; - public readonly AlgoStructureKey structure; - - public AlgoNameStructureKey(CustomOrderDefinition.CustomOneofCase base_type) - : this(base_type.type_id(), new AlgoStructureKey(base_type)) { } - - public AlgoNameStructureKey(string name, AlgoStructureKey structure) { - this.name = name; - this.structure = structure; - } - - public bool Equals(AlgoNameStructureKey other) => name == other.name && structure == other.structure; - public override bool Equals(object obj) => EqualityComparer.equals_obj(this, obj); - public override int GetHashCode() => EqualityComparer.aggregate_hash(EqualityComparer.safe_get_hash_code(name), structure.GetHashCode()); - public static bool operator ==(AlgoNameStructureKey a, AlgoNameStructureKey b) => a.Equals(b); - public static bool operator !=(AlgoNameStructureKey a, AlgoNameStructureKey b) => !a.Equals(b); - } - - struct AlgoStructureKey : IEquatable { - readonly int[] _structure; - - public AlgoStructureKey(CustomOrderDefinition.CustomOneofCase base_type) - : this(new[] { (int)base_type }) { } - - public AlgoStructureKey(CustomOrderDefinitionImmutable definition, IMaskIndexInt32 dynamic_type_index) => - _structure = AlgoStructureSerializer.to_array(definition, dynamic_type_index); - - public AlgoStructureKey(int[] structure) => - _structure = structure; - - public IReadOnlyList structure => _structure ?? Array.Empty(); - - public bool Equals(AlgoStructureKey other) { - if (_structure == null) { - return other._structure == null; - } else { - /// is not optimized to check Count/Length, since the args are . - return other._structure != null && _structure.Length == other._structure.Length && _structure.SequenceEqual(other._structure); - } - } - - public override bool Equals(object obj) => - obj is AlgoStructureKey other && Equals(other); - - public override int GetHashCode() => - _structure == null ? 0 : EqualityComparer.aggregate_hash(_structure); - - public static bool operator ==(AlgoStructureKey a, AlgoStructureKey b) => a.Equals(b); - public static bool operator !=(AlgoStructureKey a, AlgoStructureKey b) => !a.Equals(b); - } - - static class AlgoStructureSerializer { - const int - _dynamic_mask = 1 << 31, - _child_mask_offset = 30; - - public static CustomOrderDefinitionImmutable build_algoi(this AlgoStructureKey structure_key, DynamicOrderHelper dynamic_helper) => - parsei(structure_key.structure, dynamic_helper); - - public static CustomOrderDefinitionImmutable build_algo(this AlgoStructureKey structure_key, DynamicOrderHelper dynamic_helper) => - parsei(structure_key.structure, dynamic_helper); - - public static CustomOrderDefinition.CustomOneofCase order_type(this AlgoStructureKey structure_key) => - structure_key.structure.Count > 0 ? (CustomOrderDefinition.CustomOneofCase)structure_key.structure[0] : CustomOrderDefinition.CustomOneofCase.None; - - public static AlgoStructureKey structure_key(int dynamic_type) => - new AlgoStructureKey(new[] { dynamic_type | _dynamic_mask }); - - public static AlgoStructureKey structure_key(CustomOrderDefinitionImmutable algo, IMaskIndexInt32 dynamic_type_index) => - new AlgoStructureKey(to_array(algo, dynamic_type_index)); - - public static AlgoStructureKey structure_key(CustomOrderDefinition algo, IMaskIndexInt32 dynamic_type_index) => - new AlgoStructureKey(to_array(algo, dynamic_type_index)); - - public static int[] to_array(CustomOrderDefinitionImmutable algo, IMaskIndexInt32 dynamic_type_index) => - to_array(algo.CloneToMutable(), dynamic_type_index); - - public static int[] to_array(CustomOrderDefinition algo, IMaskIndexInt32 dynamic_type_index) { - int[] s = new[] { (int)algo.CustomCase }; - _build_structure(algo, ref s, dynamic_type_index); - return s; - } - - public static CustomOrderDefinitionImmutable from_array(int[] structure, DynamicOrderHelper dynamic_helper) => - parsei(structure, dynamic_helper); - - public static CustomOrderDefinitionImmutable parsei(IReadOnlyList structure, DynamicOrderHelper dynamic_helper) => - new CustomOrderDefinitionImmutable(parse(structure, dynamic_helper)); - - public static CustomOrderDefinition parse(IReadOnlyList structure, DynamicOrderHelper dynamic_helper) { - if (structure == null || structure.Count == 0) - return new CustomOrderDefinition(); - int pos = 1; - var mdef = OrderDataHelper.create_algo((CustomOrderDefinition.CustomOneofCase)structure[0]); - _build_def(structure, ref pos, ref mdef, dynamic_helper); - return mdef; - } - - public static AlgoID to_algo_id(AlgoStructureKey key, IMaskIndexInt32 dynamic_type_index) { - if (key.structure.Count == 0) - return new AlgoID(CustomOrderDefinition.CustomOneofCase.None); - int i = key.structure[0]; - return BitHelper.remove_flags(ref i, _dynamic_mask) ? new AlgoID(dynamic_type_index.from_int(i)) : new AlgoID((CustomOrderDefinition.CustomOneofCase)i); - } - - static void _build_structure(CustomOrderDefinition algo, ref int[] structure, IMaskIndexInt32 dynamic_type_index) { - if (structure == null || structure.Length == 0) - structure = new int[1]; - structure[0] = (int)algo.CustomCase; - int p = 1; - _build_structure(algo, ref structure, ref p, dynamic_type_index); - ArrayHelper.trim(ref structure, p); - } - - static void _build_structure(CustomOrderDefinition algo, ref int[] structure, ref int pos, IMaskIndexInt32 dynamic_type_index) { - IEnumerable<(CustomOrderDefinition child_algo, int field_pos)> children; - if (algo.CustomCase == CustomOrderDefinition.CustomOneofCase.Dynamic) { - ArrayHelper.ensure_capacity(ref structure, pos + 1); - structure[pos++] = dynamic_type_index.to_int(algo.Dynamic.DynamicOrderType) | _dynamic_mask; - children = algo.Dynamic.OrderParams.Where(kv => kv.Value.ValueCase == DynamicOrderParam.ValueOneofCase.AsOrderDef).Select((kv, i) => (kv.Value.AsOrderDef, i)); - } else { - var cad = OrderDataHelper.get_child_algo_data(algo); - children = cad.Select((c, i) => (c.get_child(algo), i)); - children = children.Where(c => c.child_algo != null); - } - foreach ((var child, int field_pos) in children) { - ArrayHelper.ensure_capacity(ref structure, pos + 1); - structure[pos++] = EnumMaskIndexInt32.to_int(child.CustomCase) | _child_algo_mask(field_pos); - _build_structure(child, ref structure, ref pos, dynamic_type_index); - } - } - - /// - /// Gets a mask for a particular child-algo field of a particular algo definition. - /// - /// The index wrt the deterministic enumeration of child algos for a particular definition (e.g., Hedge = 0, Child = 1). - static int _child_algo_mask(int field_pos) => 1 << (_child_mask_offset - field_pos); - - static void _build_def(IReadOnlyList structure, ref int pos, ref CustomOrderDefinition algo, DynamicOrderHelper dynamic_helper) { - var local_algo = algo; - IEnumerable<(Action assign_child, int field_pos)> children; - if (algo.CustomCase == CustomOrderDefinition.CustomOneofCase.Dynamic) { - var dyn_def = algo.Dynamic; - dyn_def.DynamicOrderType = dynamic_helper.dynamic_type_index.from_int(structure[pos++] ^ _dynamic_mask); - dynamic_helper.add_dynamic_params(ref dyn_def); - children = dyn_def.OrderParams - .Where(kv => kv.Value.ValueCase == DynamicOrderParam.ValueOneofCase.AsOrderDef) - .Select((kv, i) => (new Action(child_algo => kv.Value.AsOrderDef = child_algo), i)); - } else { - children = OrderDataHelper.get_child_algo_data(algo) - .Select((c, i) => (new Action(child_algo => c.assign_child(local_algo, child_algo)), i)); - } - using (var children_en = children.GetEnumerator()) { - while (pos < structure.Count && children_en.MoveNext()) { - (var assign_child, int field_pos) = children_en.Current; - int mask = _child_algo_mask(field_pos); - if ((structure[pos] & mask) == mask) { - var type = EnumMaskIndexInt32.from_int(structure[pos++] ^ mask); - var child_algo = OrderDataHelper.create_algo(type); - _build_def(structure, ref pos, ref child_algo, dynamic_helper); - assign_child(child_algo); - } - } - } - } - } -} diff --git a/src/client/spark/Modules/Trading/AlgoStudio/Model/AlgoStudioDefinitionTemplateModel.cs b/src/client/spark/Modules/Trading/AlgoStudio/Model/AlgoStudioDefinitionTemplateModel.cs deleted file mode 100644 index b036f0671..000000000 --- a/src/client/spark/Modules/Trading/AlgoStudio/Model/AlgoStudioDefinitionTemplateModel.cs +++ /dev/null @@ -1,319 +0,0 @@ -using bts; -using bts.api.core; -using bts.api.orderman; -using bts.persist.algo; -using bts.spark; -using mbts.utils; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Reactive.Disposables; -using System.Reactive.Linq; -using System.Threading.Tasks; - -namespace mbts.spark { - class AlgoStudioDefinitionTemplateModel : IAlgoStudioModel, IDisposable { - readonly AlgoService _service; - readonly AdminModel _admin_model; - readonly ErrorReporter _error_reporter; - readonly ObservableDemuxer _metadata_demuxer = new ObservableDemuxer(); - readonly TableUpdateDemuxer _definition_templates_demuxer; - IReadOnlyDictionary _algos = DictionaryHelper.empty(); - IReadOnlyDictionary _algo_templates = DictionaryHelper.empty(); - IDisposable _dispose; - - public AlgoStudioDefinitionTemplateModel(AlgoService service, IAlgoDefinitionMetadataService meta, AdminModel admin_model, ErrorReporter error_reporter, bts.config.AlgoStudioOptions ui_configuration) { - _service = service; - metadata_service = meta; - _admin_model = admin_model; - _error_reporter = error_reporter; - this.ui_configuration = ui_configuration; - _definition_templates_demuxer = new TableUpdateDemuxer(t => t.key, t => t.definition_key); - definitions = _service.subscribei_algos() - .Select(u => new Update( - u.all.Select(_Utils.definition_data).ToList(), - u.added.Select(_Utils.definition_data).ToList(), - u.changes.Select(ch => new Change(_Utils.definition_data(ch.Old), _Utils.definition_data(ch.New))).ToList(), - u.removed.Select(d => _Utils.definition_data(d)).ToList(), - def => def.key)) - .Table() - .Cache(); - templates = _service.subscribei_algo_templates() - .Select(u => new Update( - u.all.Select(_Utils.template_data).ToList(), - u.added.Select(_Utils.template_data).ToList(), - u.changes.Select(ch => new Change(_Utils.template_data(ch.Old), _Utils.template_data(ch.New))).ToList(), - u.removed.Select(_Utils.template_data).ToList(), - def => def.key)) - .Table() - .Cache(); - _dispose = new CompositeDisposable( - definitions.OnDispatcher().Subscribe(t => _algos = t.state), - templates.OnDispatcher().Subscribe(t => _algo_templates = t.state), - templates.Subscribe(_definition_templates_demuxer), - metadata_service.subscribe_metadata().Subscribe(_metadata_demuxer)); - } - - public IObservable> definitions { get; } - public IObservable> templates { get; } - public IAlgoDefinitionMetadataService metadata_service { get; } - public bts.config.AlgoStudioOptions ui_configuration { get; } - - public IObservable> subscribe_definition_templates(AlgoKey definition) => - _definition_templates_demuxer.subscribe(definition); - - public async Task save_definition(AlgoData definition_data) { - if (definition_data.key.is_persisted) { - // TODO: implement update op when backend ready - } else { - // create op - return await _create_definition(new CompositeAlgoDefinitionImmutable(_Utils.to_definition(definition_data))); - } - return null; - } - public async Task save_template(AlgoTemplateData template_data) { - if (template_data.key.is_persisted) { - // update op - return await _update_template(_Utils.to_recordi(template_data)); - } else { - // create op - return await _create_template(_Utils.to_templatei(template_data)); - } - } - - /// - /// The api is not used here (there are some unresolved dependency issues with definitions on the backend). - /// The definition is marked as hidden in the AlgoMetadata stored on the server. - /// - /// For implementation details, see: , - /// - public async Task remove_definition(AlgoKey key) { - if (_algos.TryGetValue(key, out AlgoData curr)) { - if (_definition_templates_demuxer.try_get_values(key, out IReadOnlyDictionary tmps)) { - foreach (var t in tmps.Values) - await remove_template(t.key); - } - await metadata_service.hide_definition(key); - return true; - } - return false; - } - - public async Task remove_template(AlgoKey template_key) { - var req = new AlgoServiceRemoveRequest(); - _Utils.set_key(ref req, template_key); - var reply = await _safe_execute(() => _service.remove_template_async(req), ActionMetadata.remove_template); - return reply.success && reply.value.Success; - } - - public void Dispose() => - Disposable.dispose(ref _dispose); - - async Task _create_definition(CompositeAlgoDefinitionImmutable definition) => - await _create_definition(definition, _admin_model.user.id); - - async Task _create_template(AlgoTemplateImmutable template) { - var (value, success) = await _error_reporter.safe_execute(() => _service.create_template_async( - new TemplateCreateRequest { UserId = _admin_model.user.id, NewTemplate = template.CloneToMutable() }), - r => r.Success, r => r.ErrMsg, ActionMetadata.CreateTemplate); - if (success) - return _Utils.template_data(value.Record); - return null; - } - - async Task _update_template(AlgoTemplateRecordImmutable template) { - var (value, success) = await _error_reporter.safe_execute(() => _service.update_template_async( - new TemplateUpdateRequest { Key = template.Key, UpdatedTemplate = template.AlgoTemplate.CloneToMutable() }), - r => r.Success, r => r.ErrMsg.ToString(), ActionMetadata.UpdateTemplate); - if (success) - return _Utils.template_data(template); - return null; - } - - async Task _create_definition(CompositeAlgoDefinitionImmutable definition, uint user_id) { - (var result, var success) = await _error_reporter.safe_execute(() => _service.create_composite_algo_async( - new CompositeAlgoCreateRequest { - NewAlgo = definition.CloneToMutable(), - UserId = user_id - }), r => r.Success, r => r.ErrMsg, "create definition"); - return success ? _Utils.definition_data(new CompositeAlgoRecordImmutable(result.Record)) : (AlgoData?)null; - } - - async Task> _safe_execute(Func>> execute, IActionMetadata am) { - try { - var result = await execute(); - if (!result.success) { - _report_error(am.present_progressive_desc, result.error_message); - } else if (!am.get_success(result.value)) { - _report_error(am.present_progressive_desc, am.get_error_msg(result.value)); - } - return result; - } catch (Exception ex) { - _report_error(am.present_progressive_desc, ex.ToString()); - } - return new Result(bts.api.ApiError.UnexpectedResponse); - } - - void _report_error(string present_progressive_desc, string msg) => - _error_reporter.report_error($"Error {present_progressive_desc}: {msg}", AlgoStudioWindow.NAME, System.Windows.MessageBoxImage.Warning); - - void _report_no_user_id(string desc) => - _error_reporter.report_error($"{desc} failed: did not find current user id"); - - // used for error handling/reporting - interface IActionMetadata { - string desc { get; } - string present_progressive_desc { get; } - } - - interface IActionMetadata : IActionMetadata { - bool get_success(TReply reply); - string get_error_msg(TReply reply); - } - - static class ActionMetadata { - public const string - CreateDefinition = "create definition", - UpdateDefinition = "update definition", - CreateTemplate = "create template", - UpdateTemplate = "update template"; - public static readonly IActionMetadata update_template = new Impl(_update, _template, r => r.Success, r => r.ErrMsg.ToString()); - public static readonly IActionMetadata remove_template = new Impl(_delete, _template, r => r.Success, r => r.ErrMsg.ToString()); - public static readonly IActionMetadata create_template = new Impl(_create, _template, r => r.Success, r => r.ErrMsg); - public static readonly IActionMetadata create_definition = new Impl(_create, _definition, r => r.Success, r => r.ErrMsg); - - static readonly DescTuple _create = new DescTuple("create", "creating"), _update = new DescTuple("update", "updating"), _delete = new DescTuple("delete", "deleting"); - static readonly string _definition = "definition", _template = "template"; - - class Impl : IActionMetadata { - readonly DescTuple _desc; - readonly string _subject; - readonly Func _get_success; - readonly Func _get_error_msg; - - public Impl(DescTuple desc, string subject, Func get_success, Func get_error_msg) { - _desc = desc; - _subject = subject; - _get_success = get_success; - _get_error_msg = get_error_msg; - } - public string desc => _desc.desc; - public string present_progressive_desc => _desc.present_progressive_desc; - public bool get_success(T reply) => _get_success(reply); - public string get_error_msg(T reply) => _get_error_msg(reply); - } - - struct DescTuple { - public readonly string desc, present_progressive_desc; - public DescTuple(string desc, string present_progressive_desc) { - this.desc = desc; - this.present_progressive_desc = present_progressive_desc; - } - } - } - - /// - /// The AlgoService protobuf types have been extracted out of the viewmodels (, , , ). - /// The viewmodels instead use these types to represent the data: is used in place of , and is used in place of . - /// This thin abstraction isolates the server-side from the client-side, so if one day the server side types change, we won't need to change any client-side code except the methods below which handle the conversion from server type to corresponding client type. - /// There are a couple other methods in here as well (this is an extensions class afterall), but [John]I am going out of town soon (1/6/18) and did not get a chance to organize these methods beyond containing them in . - /// - static class _Utils { - // AlgoTemplateImmutable custom_order_definition(i) - public static CustomOrderDefinitionImmutable custom_order_definitioni(AlgoTemplateImmutable templatei) { - switch (templatei.AlgoParamsCase) { - case AlgoTemplate.AlgoParamsOneofCase.CompositeAlgoParams: return templatei.CompositeAlgoParams.Algo; - case AlgoTemplate.AlgoParamsOneofCase.SystemAlgoParams: return templatei.SystemAlgoParams; - default: throw ExceptionBuilder.Argument.unexpected_case(templatei.AlgoParamsCase, nameof(templatei)); - } - } - - public static AlgoData definition_data(AlgoTemplateImmutable templatei) { - switch (templatei.AlgoParamsCase) { - case AlgoTemplate.AlgoParamsOneofCase.CompositeAlgoParams: return definition_data(templatei.CompositeAlgoParams); - case AlgoTemplate.AlgoParamsOneofCase.SystemAlgoParams: - return new AlgoData( - templatei.SystemAlgoParams, - templatei.SystemAlgoParams.CustomCase.display_name(), - get_key(templatei.SystemAlgoParams)); - default: throw ExceptionBuilder.Argument.unexpected_case(templatei.AlgoParamsCase, nameof(templatei)); - } - } - - public static AlgoData definition_data(CompositeAlgoRecordImmutable recordi) => new AlgoData(recordi.AlgoDefinition.Algo, recordi.AlgoDefinition.Name, get_key(recordi)); - - public static AlgoData definition_data(CompositeAlgoDefinitionImmutable definitioni) => - new AlgoData(definitioni.Algo, definitioni.Name, get_key(definitioni)); - - public static AlgoData? definition_data(Result result) { - if (result.success && result.value.Success) { - var r = result.value.Record; - return new AlgoData(new CustomOrderDefinitionImmutable(r.AlgoDefinition.Algo), r.AlgoDefinition.Name, new AlgoKey(new AlgoPersistedKey(r.Key))); - } else return null; - } - - // AlgoTemplateRecord(Immutable) template data - public static AlgoTemplateData template_data(AlgoTemplateRecord record) => template_data(new AlgoTemplateRecordImmutable(record)); - public static AlgoTemplateData template_data(AlgoTemplateRecordImmutable recordi) => new AlgoTemplateData(custom_order_definitioni(recordi.AlgoTemplate), recordi.AlgoTemplate.Name, get_key(recordi), definition_data(recordi.AlgoTemplate)); - - public static CompositeAlgoDefinition to_definition(AlgoData definition_data) => - new CompositeAlgoDefinition { - Name = definition_data.name, - Algo = definition_data.value.CloneToMutable() - }; - - // AlgoTemplateData to_record(i) - public static AlgoTemplateRecord to_record(AlgoTemplateData template) { - var record = new AlgoTemplateRecord { - AlgoTemplate = new AlgoTemplate { - Name = template.name, - CompositeAlgoParams = new CompositeAlgoDefinition { - Name = template.definition.name, - Algo = template.value.CloneToMutable() - } - } - }; - set_key(ref record, template.key); - return record; - } - public static AlgoTemplateRecordImmutable to_recordi(AlgoTemplateData template) => new AlgoTemplateRecordImmutable(to_record(template)); - - // AlgoTemplateData to_template(i) - public static AlgoTemplate to_template(AlgoTemplateData template) => - new AlgoTemplate { - Name = template.name, - CompositeAlgoParams = new CompositeAlgoDefinition { - Name = template.definition.name, - Algo = template.value.CloneToMutable() - } - }; - public static AlgoTemplateImmutable to_templatei(AlgoTemplateData template) => new AlgoTemplateImmutable(to_template(template)); - - public static AlgoKey get_key(CompositeAlgoRecordImmutable recordi) => new AlgoKey(new AlgoPersistedKey(recordi.Key)); - public static AlgoKey get_key(AlgoTemplateRecordImmutable recordi) => new AlgoKey(new AlgoPersistedKey(recordi.Key)); - public static AlgoKey get_key(CompositeAlgoDefinitionImmutable definitioni) => new AlgoKey(new AlgoPersistedKey(definitioni.Name)); - public static AlgoKey get_key(CustomOrderDefinitionImmutable custom_order_definitioni) => new AlgoKey(custom_order_definitioni.CustomCase); - - public static void set_key(ref AlgoTemplateRecord record, AlgoKey key) { - switch (key.mode) { - case AlgoKey.Mode.Persisted: - switch (key.persisted.mode) { - case AlgoPersistedKey.Mode.String: - record.Key = key.persisted.id_string; break; - } - break; - } - } - public static void set_key(ref AlgoServiceRemoveRequest request, AlgoKey key) { - switch (key.mode) { - case AlgoKey.Mode.Persisted: - switch (key.persisted.mode) { - case AlgoPersistedKey.Mode.String: - request.Key = key.persisted.id_string; break; - } - break; - } - } - } - } -} \ No newline at end of file diff --git a/src/client/spark/Modules/Trading/AlgoStudio/Model/AlgoStudioFlatDefinitionModel.cs b/src/client/spark/Modules/Trading/AlgoStudio/Model/AlgoStudioFlatDefinitionModel.cs index 57518ae9f..a955270d7 100644 --- a/src/client/spark/Modules/Trading/AlgoStudio/Model/AlgoStudioFlatDefinitionModel.cs +++ b/src/client/spark/Modules/Trading/AlgoStudio/Model/AlgoStudioFlatDefinitionModel.cs @@ -1,15 +1,16 @@ using bts; using bts.api.core; using bts.api.orderman.algo; -using bts.persist.algo; using bts.spark; using mbts.utils; using System; using System.Collections.Generic; +using System.ComponentModel.Composition; using System.Reactive.Linq; using System.Threading.Tasks; namespace mbts.spark { + [Export(typeof(IAlgoStudioModel))] class AlgoStudioFlatDefinitionModel : IAlgoStudioModel, IDisposable { readonly AlgoDefinitionService _service; readonly AdminModel _admin_model; @@ -18,12 +19,12 @@ namespace mbts.spark { IReadOnlyDictionary _algo_templates = DictionaryHelper.empty(); IDisposable _dispose; - public AlgoStudioFlatDefinitionModel(AlgoDefinitionService service, IAlgoDefinitionMetadataService metadata_service, AdminModel admin_model, ErrorReporter error_reporter, bts.config.AlgoStudioOptions ui_configuration) { + [ImportingConstructor] + public AlgoStudioFlatDefinitionModel(AlgoDefinitionService service, IAlgoDefinitionMetadataService metadata_service, AdminModel admin_model, ErrorReporter error_reporter) { _service = service; this.metadata_service = metadata_service; _admin_model = admin_model; _error_reporter = error_reporter; - this.ui_configuration = ui_configuration; definitions = service.subscribei_algo_definitions() .Filter(r => r.Metadata.IsActive && r.Metadata.CreatorUserId == _admin_model.user.id) @@ -35,7 +36,7 @@ namespace mbts.spark { public IObservable> definitions { get; } public IObservable> templates => Observable.Empty>(); public IAlgoDefinitionMetadataService metadata_service { get; } - public bts.config.AlgoStudioOptions ui_configuration { get; } + public bts.config.AlgoStudioOptions ui_configuration { get; } = config.Configuration.get(); public IObservable> subscribe_definition_templates(AlgoKey definition_key) => Observable.Return(TableUpdate.mk_empty(t => t.key)); @@ -71,10 +72,10 @@ namespace mbts.spark { new AlgoDefinitionImmutable(_template(definition_data)); static AlgoData _definition_data(AlgoDefinitionRecordImmutable recordi) => - new AlgoData(recordi.Algo.Definition, recordi.Algo.Name, _key(recordi)); + AlgoData.from_record(recordi); static AlgoKey _key(AlgoDefinitionRecordImmutable recordi) => - new AlgoKey(new AlgoPersistedKey(recordi.Key)); + AlgoKey.from_composite_key(recordi.Key); static AlgoDefinitionUpdateRequest _with_key(AlgoDefinitionUpdateRequest request, AlgoKey key) { _set_key(ref request, key); @@ -83,9 +84,10 @@ namespace mbts.spark { static void _set_key(ref AlgoDefinitionUpdateRequest request, AlgoKey key) { switch (key.mode) { - case AlgoKey.Mode.Persisted: request.Key = key.persisted.id_uint; break; + case AlgoKey.Mode.Persisted: request.Key = key.persisted; break; case AlgoKey.Mode.Unpersisted: case AlgoKey.Mode.Factory: + case AlgoKey.Mode.Dynamic: case AlgoKey.Mode.None: request.Key = 0; break; default: throw ExceptionBuilder.Argument.unexpected_case(key.mode, nameof(key)); } @@ -93,7 +95,7 @@ namespace mbts.spark { static void _set_key(ref AlgoDefinitionRemoveRequest request, AlgoKey key) { switch (key.mode) { - case AlgoKey.Mode.Persisted: request.Key = key.persisted.id_uint; break; + case AlgoKey.Mode.Persisted: request.Key = key.persisted; break; default: throw ExceptionBuilder.Argument.unexpected_case(key.mode, nameof(key)); } } diff --git a/src/client/spark/Modules/Trading/AlgoStudio/Model/IAlgoStudioModel.cs b/src/client/spark/Modules/Trading/AlgoStudio/Model/IAlgoStudioModel.cs index 0d2b85cbe..acbcdffb5 100644 --- a/src/client/spark/Modules/Trading/AlgoStudio/Model/IAlgoStudioModel.cs +++ b/src/client/spark/Modules/Trading/AlgoStudio/Model/IAlgoStudioModel.cs @@ -1,10 +1,7 @@ using bts; -using bts.api; using bts.api.core; -using bts.spark; using System; using System.Collections.Generic; -using System.ComponentModel.Composition; using System.Threading.Tasks; namespace mbts.spark { @@ -20,34 +17,13 @@ namespace mbts.spark { bts.config.AlgoStudioOptions ui_configuration { get; } } - class AlgoStudioModelExporter { - [ImportingConstructor] - AlgoStudioModelExporter(Spark.AlgoServiceWrapper service_wrapper, IAlgoDefinitionMetadataService meta, AdminModel admin_model, ErrorReporter error_reporter) { - var ui_configuration = config.Configuration.get(); - switch (service_wrapper.mode) { - case Spark.AlgoServiceWrapper.Mode.Flat: model = new AlgoStudioFlatDefinitionModel(service_wrapper.flat, meta, admin_model, error_reporter, ui_configuration); break; - case Spark.AlgoServiceWrapper.Mode.Hierarchical: model = new AlgoStudioDefinitionTemplateModel(service_wrapper.hierarhical, meta, admin_model, error_reporter, ui_configuration); break; - } - } - - [Export] - public IAlgoStudioModel model { get; } - } - static class AlgoStudioModelUtils { - public static bool templates_enabled(this IAlgoStudioModel model) => - get_templates_enabled(model.ui_configuration); - - public static bool get_templates_enabled(bts.config.AlgoStudioOptions ui_configuration) => - ui_configuration.add_template_button != bts.config.AlgoStudioOptions.AddTemplateButton.None; - public static IReadOnlyDictionary get_dynamic_resources(bts.config.AlgoStudioOptions ui_configuration) => new Dictionary { { AlgoStudioWindow.ShowAlgoToolBarRenameDefinitionKey, ui_configuration.can_modify_definition_name && ui_configuration.show_algo_toolbar_rename }, { AlgoStudioWindow.ShowAlgoToolBarSaveDefinitionKey, ui_configuration.can_modify_definition_values && ui_configuration.show_algo_toolbar_save }, { AlgoStudioWindow.ShowAlgoToolBarRevertDefinitionKey, ui_configuration.show_algo_toolbar_revert }, - { AlgoStudioWindow.ShowAlgoToolBarUndoRedoDefinitionKey, ui_configuration.show_algo_toolbar_undo_redo }, - { AlgoStudioWindow.TemplatesEnabledKey, get_templates_enabled(ui_configuration) } + { AlgoStudioWindow.ShowAlgoToolBarUndoRedoDefinitionKey, ui_configuration.show_algo_toolbar_undo_redo } }; } } \ No newline at end of file diff --git a/src/client/spark/Modules/Trading/AlgoStudio/Model/Metadata/AlgoDefinitionMetadata.cs b/src/client/spark/Modules/Trading/AlgoStudio/Model/Metadata/AlgoDefinitionMetadata.cs index aa536d1bf..cc13fd049 100644 --- a/src/client/spark/Modules/Trading/AlgoStudio/Model/Metadata/AlgoDefinitionMetadata.cs +++ b/src/client/spark/Modules/Trading/AlgoStudio/Model/Metadata/AlgoDefinitionMetadata.cs @@ -35,9 +35,9 @@ namespace mbts.spark { internal AlgoDefinitionPersistedMetadata to_persisted() => id.mode != AlgoKey.Mode.Persisted ? throw new InvalidOperationException("Metadata does not have a persisted key.") : - new AlgoDefinitionPersistedMetadata(id.persisted, - default_template.mode == AlgoKey.Mode.Persisted ? default_template.persisted : default, - favorite_templates.Where(t => t.mode == AlgoKey.Mode.Persisted).Select(t => t.persisted).ToArray(), + new AlgoDefinitionPersistedMetadata(new AlgoPersistedKey(id.persisted), + default_template.mode == AlgoKey.Mode.Persisted ? new AlgoPersistedKey(default_template.persisted) : default, + favorite_templates.Where(t => t.mode == AlgoKey.Mode.Persisted).Select(t => new AlgoPersistedKey(t.persisted)).ToArray(), is_favorite, is_hidden, abbreviation, new NullableColorProto(badge_color)); public AlgoDefinitionMetadata with(AlgoKey? id = null, AlgoKey? default_template = null, IEnumerable favorite_templates = null, bool? is_favorite = null, bool? is_hidden = null, string abbreviation = null, NullableColorProto? badge_color = null) => diff --git a/src/client/spark/Modules/Trading/AlgoStudio/Utils/AlgoCollectionHelper.cs b/src/client/spark/Modules/Trading/AlgoStudio/Utils/AlgoCollectionHelper.cs index b66b82839..4414381f9 100644 --- a/src/client/spark/Modules/Trading/AlgoStudio/Utils/AlgoCollectionHelper.cs +++ b/src/client/spark/Modules/Trading/AlgoStudio/Utils/AlgoCollectionHelper.cs @@ -83,7 +83,8 @@ namespace mbts.spark { public static AlgoDisplayGroup display_group(this AlgoKey key) { switch (key.mode) { - case AlgoKey.Mode.Factory: return display_group(key.factory.structure.order_type()); + case AlgoKey.Mode.Factory: return display_group(key.factory); + case AlgoKey.Mode.Dynamic: return AlgoDisplayGroup.API; case AlgoKey.Mode.Unpersisted: case AlgoKey.Mode.Persisted: return AlgoDisplayGroup.Studio; diff --git a/src/client/spark/Modules/Trading/AlgoStudio/VM/AlgoDefinitionTemplateVM.cs b/src/client/spark/Modules/Trading/AlgoStudio/VM/AlgoDefinitionTemplateVM.cs deleted file mode 100644 index 27cfd6f91..000000000 --- a/src/client/spark/Modules/Trading/AlgoStudio/VM/AlgoDefinitionTemplateVM.cs +++ /dev/null @@ -1,243 +0,0 @@ -using bts; -using bts.api.orderman; -using bts.utils; -using mbts.spark.utilities; -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.Reactive.Linq; -using System.Windows.Input; -using VisualStateNames = mbts.ui.spark.AlgoStudioView.VisualStateNames; - -namespace mbts.spark { - class AlgoDefinitionTemplateVM : DisposableViewModelBase, IAlgoStudioContentVM, IEquatable { - /// is referenced by an x:Static extension in OrderDetailsPopupControl.xaml . - /// In most cases, works just like , but for nested types, such as . - /// However, when the former is used to denote the DataType of a DataTemplate, a strange XamlReader exception is thrown at runtime. - /// After spending ~15 minutes investigating what was happening, [John]I decided it was more trouble than it was worth and opted for this workaround. - public static readonly Type CustomType = typeof(CustomTemplatePlaceholderVM); - readonly OrdersModel _model; - readonly VisualStateModel _edit_pane_vs_model = new VisualStateModel(), _tree_view_vs_model = new VisualStateModel(); - /// Note: the difference between and is that the former implements push/pop functionality so the user may undo/redo (like ctrl+z/ctrl+y in text editors), - /// while the latter is a lazy delegate-based container for the most recent value (). - readonly EditStack _edit_stack = new EditStack(); - readonly VersionContainer _version; - readonly DeferrableActionWrapper _refresh_on_local_change; - readonly Property _algo_root; - readonly DelegateProperty _can_undo, _can_redo, _is_dirty; - readonly Property _is_default, _is_favorite, _is_selected; - readonly Property _name, _abbreviation; - // maintains the state of each algo-root, so the user may change the definition root back and forth without any loss of state amongst the templates - Snapshot _committed; - - public AlgoDefinitionTemplateVM(AlgoDefinitionVM owner, OrdersModel model, AlgoData data, AlgoEditingPermissions editing_permissions = AlgoEditingPermissions.AllowEditValues) { - // init core data - this.owner = owner; - _model = model; - key = data.key; - _version = new VersionContainer(_snapshot); - // maintain states for different algo roots, so they aren't lost when the user changes the root algo type - var algo_map = new Dictionary { - { data.key, algo_vm_factory(data.value) } - }; - // init backing props - _name = backing(nameof(this.name), name); - _abbreviation = backing(nameof(abbreviation), string.Empty); - _is_default = backing(nameof(is_default), false); - _is_favorite = backing(nameof(is_favorite), false); - _is_selected = backing(nameof(is_selected), false); - _algo_root = backing(nameof(algo_root), get_algo_root(owner.algo_root)); - _committed = _version.value; - _can_redo = backing(nameof(can_redo), () => _edit_stack.get_can_redo(_version.value)); - _can_undo = backing(nameof(can_undo), () => _edit_stack.get_can_undo(_version.value)); - _is_dirty = backing(nameof(is_dirty), () => !_committed.Equals(_version.value)); - _can_redo.Changed += on_can_redo_changed; - _can_undo.Changed += on_can_undo_changed; - set_as_default_cmd = new DelegateCommand(() => { - if (!is_default && key.mode == AlgoKey.Mode.Persisted) - _model.algo_model.metadata_service.set_as_default(owner.key, key).ignore(); - }); - // init visual states - // TODO: implement these features in IAlgoMetadataService; until then, set the appropriate visual states. - _edit_pane_vs_model.set_state(VisualStateNames.Abbreviation.GroupName, VisualStateNames.Abbreviation.NotSupportedForTemplates); - _tree_view_vs_model.set_state(VisualStateNames.FavoriteToggleButton.GroupName, VisualStateNames.FavoriteToggleButton.Inactive); - switch (key.mode) { - case AlgoKey.Mode.Persisted: - _edit_stack.push(_committed); - _edit_pane_vs_model.set_state(VisualStateNames.Name.GroupName, VisualStateNames.Name.Active); - break; - case AlgoKey.Mode.Unpersisted: _edit_pane_vs_model.set_state(VisualStateNames.Name.GroupName, VisualStateNames.Name.Active); break; - case AlgoKey.Mode.Factory: _edit_pane_vs_model.set_state(VisualStateNames.Name.GroupName, VisualStateNames.Name.Inactive); break; - } - // set hooks/subscriptions - _refresh_on_local_change = new DeferrableActionWrapper(on_local_changed); - _dispose = new System.Reactive.Disposables.CompositeDisposable( - as_demuxer().subscribe_many(_refresh_on_local_change.execute, nameof(name), nameof(abbreviation), nameof(is_default), nameof(is_favorite)), - owner.observe_algo_root().Subscribe(r => _algo_root.set(get_algo_root(r))), - _algo_root.observe_current(true).SelectManyInSeries(r => r?.subscribe_definition()).Subscribe(_ => _refresh_on_local_change.execute()), - Disposable.wrap_collection(algo_map.Values)) { - () => { - _can_redo.Changed -= on_can_redo_changed; - _can_undo.Changed -= on_can_undo_changed; - } - }; - // local methods - IAlgoVM algo_vm_factory(CustomOrderDefinitionImmutable def) => OrderTypeVMFactory.create(new AlgoData(def, def.CustomCase.display_name(), OrderDataHelper.get_shallow_factory_key(def)), editing_permissions); - IAlgoVM get_algo_root(IAlgoVM owner_root) { - var key = new AlgoKey(owner_root.order_type); - if (algo_map.TryGetValue(key, out IAlgoVM vm)) { - vm.load_structure(owner_root.definition); - } else { - vm = algo_map.GetOrAdd(key, ot => algo_vm_factory(owner_root.definition)); - } - return vm; - } - void on_can_undo_changed(bool oldval, bool newval) => can_undo_changed?.Invoke(); - void on_can_redo_changed(bool oldval, bool newval) => can_redo_changed?.Invoke(); - void on_local_changed() { - _version.increment_version(); - _edit_stack.push_distinct(_version.value); - _is_dirty.refresh(); - _refresh_undo_redo(); - } - } - - public event Action can_redo_changed, can_undo_changed; - public event PropertyChange algo_root_changed { add => _algo_root.Changed += value; remove => _algo_root.Changed -= value; } - - public AlgoDefinitionVM owner { get; } - public AlgoKey owner_key => owner.key; - public AlgoKey key { get; } - public string name { get => _name.Value; set => _name.set(value); } - public string abbreviation { get => _abbreviation.Value; set => _abbreviation.set(value); } - public bool is_dirty => _is_dirty.Value; - public bool can_redo => _can_redo.Value; - public bool can_undo => _can_undo.Value; - public bool is_default => _is_default.Value; - public bool is_favorite { get => _is_favorite.Value; set => _is_favorite.set(value); } - public IAlgoVM algo_root => _algo_root.Value; - public virtual bool is_custom_placeholder => false; - public bool is_selected { get => _is_selected.Value; set => _is_selected.set(value); } - public bool is_expanded => false; - public bool is_persisted => key.mode == AlgoKey.Mode.Persisted; - public ObservableCollection edit_pane_visual_states => _edit_pane_vs_model.states; - public ObservableCollection tree_view_visual_states => _tree_view_vs_model.states; - public ICommand set_as_default_cmd { get; } - - public IObservable observe_is_dirty() => _is_dirty.observe_current(true); - public void undo() => _restore(_edit_stack.try_undo); - public void redo() => _restore(_edit_stack.try_redo); - - public void on_meta(bool is_default, bool is_favorite) { - _is_default.set(is_default); - _is_favorite.set(is_favorite); - } - - public AlgoData create_def_data() => - new AlgoData(algo_root.definition, name, key); - - public AlgoTemplateData create() => - create(owner.create_algo_def()); - - public AlgoTemplateData create(AlgoData record) { - if (!OrderDataHelper.EqualsHelpers.structure_equals(algo_root.definition, record.value)) - throw new InvalidOperationException("AlgoTemplate's algo structure does not match that of its parent."); - return new AlgoTemplateData(algo_root.definition, name, key, record); - } - - public AlgoDefinitionTemplateVM to_persisted(AlgoDefinitionVM persisted_owner, AlgoData template) => - new AlgoDefinitionTemplateVM(persisted_owner, _model, template); - - public void load_committed() => _load_from(_committed.name, _committed.definition, true); - - public void load_from(AlgoTemplateData value) { - if (key.mode != AlgoKey.Mode.Persisted) - throw new InvalidOperationException("AlgoStructure has not been saved yet."); - else if (value.key != key) - throw new InvalidOperationException("Value id does not match this id."); - _load_from(value.name, value.value, true); - } - - public bool Equals(AlgoDefinitionTemplateVM other) => other != null && key == other.key; - public override bool Equals(object obj) => Equals(obj as AlgoDefinitionTemplateVM); - public override int GetHashCode() => key.GetHashCode(); - - void _load_from(string new_name, CustomOrderDefinitionImmutable new_def, bool update_committed) { - using (_refresh_on_local_change.defer_execution()) { - name = new_name; - algo_root.load_from(new_def); - } - if (update_committed) { - _committed = _version.value; - _is_dirty.refresh(); - } - } - - void _refresh_undo_redo() { - _can_redo.refresh(); - _can_undo.refresh(); - } - - void _restore(TryGetValue try_get_snapshot) { - while (try_get_snapshot(out Snapshot next_state)) { - if (!_version.value.Equals(next_state)) { - _load_from(next_state.name, next_state.definition, false); - break; - } - } - } - - Snapshot _snapshot() => - new Snapshot(name, abbreviation, algo_root?.definition ?? new CustomOrderDefinitionImmutable(new CustomOrderDefinition()), is_default, is_favorite); - - struct Snapshot : IEquatable { - public readonly string name, abbreviation; - public readonly CustomOrderDefinitionImmutable definition; - public readonly bool is_default, is_favorite; - - public Snapshot(string name, string abbreviation, CustomOrderDefinitionImmutable definition, bool is_default, bool is_favorite) { - this.name = name; - this.abbreviation = abbreviation; - this.definition = definition; - this.is_default = is_default; - this.is_favorite = is_favorite; - } - - public bool Equals(Snapshot other) => - name == other.name && - abbreviation == other.abbreviation && - is_default == other.is_default && - is_favorite == other.is_favorite && - OrderDataHelper.EqualsHelpers.equals(definition, other.definition); - - public override bool Equals(object obj) => - EqualityComparer.equals_obj(this, obj); - - public override int GetHashCode() => - EqualityComparer.aggregate_hash( - EqualityComparer.safe_aggregate_hash(name), - EqualityComparer.safe_aggregate_hash(abbreviation), - is_default.GetHashCode(), - is_favorite.GetHashCode(), - OrderDataHelper.EqualsHelpers.custom_order_def_compareri.GetHashCode(definition)); - - public static bool operator ==(Snapshot a, Snapshot b) => a.Equals(b); - public static bool operator !=(Snapshot a, Snapshot b) => !a.Equals(b); - } - - public class CustomTemplatePlaceholderVM : AlgoDefinitionTemplateVM { - const string _custom_name = "(Custom)"; - - public CustomTemplatePlaceholderVM(AlgoDefinitionVM owner, OrdersModel model, CustomOrderDefinitionImmutable definition) - : base(owner, model, new AlgoData(definition, _custom_name, new AlgoKey(Guid.NewGuid())), AlgoEditingPermissions.AllowEditStructure | AlgoEditingPermissions.AllowEditValues) { - _edit_stack.reset(_snapshot()); - } - - public override bool is_custom_placeholder => true; - } - } -} \ No newline at end of file diff --git a/src/client/spark/Modules/Trading/AlgoStudio/VM/AlgoDefinitionVM.cs b/src/client/spark/Modules/Trading/AlgoStudio/VM/AlgoDefinitionVM.cs index 7ec794043..6c29af115 100644 --- a/src/client/spark/Modules/Trading/AlgoStudio/VM/AlgoDefinitionVM.cs +++ b/src/client/spark/Modules/Trading/AlgoStudio/VM/AlgoDefinitionVM.cs @@ -1,4 +1,4 @@ -using bts.api.core; +using bts; using bts.api.orderman; using bts.collections; using bts.proto; @@ -6,7 +6,6 @@ using bts.utils; using mbts.collections; using mbts.spark.utilities; using mbts.ui; -using mbts.ui.controls; using mbts.ui.controls.color_picker; using mbts.ui.shell; using mbts.ui.utility; @@ -18,7 +17,6 @@ using System.Collections.Specialized; using System.Linq; using System.Reactive.Disposables; using System.Reactive.Linq; -using System.Windows.Data; using System.Windows.Media; using VisualStateNames = mbts.ui.spark.AlgoStudioView.VisualStateNames; @@ -36,18 +34,14 @@ namespace mbts.spark { public static readonly CustomOrderDefinitionImmutable new_algo_def = OrderDataHelper.Defaults.CustomOrderDefinitionImmutable(CustomOrderDefinition.CustomOneofCase.Iceberg); readonly OrdersModel _model; readonly VisualStateModel _edit_pane_vs_model = new VisualStateModel(), _tree_view_vs_model = new VisualStateModel(); - readonly ObservableKeyedCollection _templates = new ObservableKeyedCollection(t => t.key); readonly EditStack _edit_stack = new EditStack(); readonly VersionContainer _version; readonly Property _is_expanded, _is_selected; readonly Property _algo_root, _visible_algo_root; - readonly Property _selected_template; readonly DelegateProperty _is_favorite, _is_dirty, _can_undo, _can_redo; readonly Property _name, _abbreviation; readonly ObservableKeyedCollection _algo_roots = new ObservableKeyedCollection(vm => vm.id); - readonly ObservableAppendCollection _templates_with_custom; readonly DeferrableActionWrapper _refresh_on_local_changes; - readonly ReactiveThresholdMonitor _any_templates_dirty_monitor = new ReactiveThresholdMonitor(t => t.observe_is_dirty()); readonly Property _selected_format; readonly EnumMaskInt32 _permissions_mask = new EnumMaskInt32(); @@ -55,18 +49,12 @@ namespace mbts.spark { Brush _badge_fill; Snapshot? _committed; AlgoDefinitionMetadata _metadata; - TableUpdateBuffer _template_update_buffer; - bool _connected; - public static AlgoDefinitionVM create(OrdersModel model, AlgoData data, bool connect = false, AlgoFormats init_format = AlgoFormats.Exchange, AlgoEditingPermissions editing_permissions = (AlgoEditingPermissions)int.MaxValue) { - var rv = new AlgoDefinitionVM(model, data, init_format, editing_permissions); - if (connect) - rv.connect(); - return rv; - } + public static AlgoDefinitionVM create(OrdersModel model, AlgoData data, AlgoFormats init_format = AlgoFormats.Exchange, AlgoEditingPermissions editing_permissions = (AlgoEditingPermissions)int.MaxValue) => + new AlgoDefinitionVM(model, data, init_format, editing_permissions); public static AlgoDefinitionVM create_placeholder(OrdersModel model, CustomOrderDefinitionImmutable def, string name, AlgoFormats init_format) => - new AlgoDefinitionVM(model, new AlgoData(def, name, new AlgoKey(Guid.NewGuid())), init_format, (AlgoEditingPermissions)int.MaxValue); + new AlgoDefinitionVM(model, AlgoData.create_unpersisted(def, name), init_format, (AlgoEditingPermissions)int.MaxValue); AlgoDefinitionVM(OrdersModel model, AlgoData def_data, AlgoFormats init_format, AlgoEditingPermissions init_permissions) { // init core data @@ -78,20 +66,8 @@ namespace mbts.spark { editing_permissions_mask ^= (AlgoEditingPermissions.AllowEditValues | AlgoEditingPermissions.AllowSaveValues); if (!model.algo_model.ui_configuration.can_modify_definition_structure) editing_permissions_mask ^= (AlgoEditingPermissions.AllowEditStructure | AlgoEditingPermissions.AllowSaveStructure); - else if (model.algo_model.templates_enabled()) { - resources.Add(_templates.Subscribe((s, e) => { - if (_templates.Count == 0) { - editing_permissions_mask |= AlgoEditingPermissions.AllowEditStructure | AlgoEditingPermissions.AllowSaveStructure; - } else { - editing_permissions_mask ^= (AlgoEditingPermissions.AllowEditStructure | AlgoEditingPermissions.AllowSaveStructure); - } - })); - } key = def_data.key; algos_view = ObservableAutoWrapper.create_sorted_wrapper(_algo_roots, AlgoCollectionHelper.algo_vm_comparer); - _template_update_buffer = new TableUpdateBuffer(t => t.key); - _templates_with_custom = new ObservableAppendCollection(templates); - templates_view = (ListCollectionView)CollectionViewSource.GetDefaultView(_templates_with_custom); custom_badge_color_palettes.AddRange(ColorPalette.all_presets(model.factory).Select(p => new ColorPaletteVM(p))); _version = new VersionContainer(_snapshot); var conf = _model.algo_model.ui_configuration; @@ -99,87 +75,80 @@ namespace mbts.spark { _name = backing(nameof(name), def_data.name); _abbreviation = backing(nameof(abbreviation), string.Empty); _selected_format = backing(nameof(selected_format), init_format); - _selected_template = backing(nameof(selected_template)); _is_favorite = backing(nameof(is_favorite), () => _favorite_index.HasValue); _is_expanded = backing(nameof(is_expanded), true); _is_selected = backing(nameof(is_selected), true); _is_dirty = backing(nameof(is_dirty), () => key.mode == AlgoKey.Mode.Unpersisted || !_committed.HasValue || !_committed.Value.Equals(_version.value)); - var factory_def_data = def_data.key.mode == AlgoKey.Mode.Factory ? def_data : new AlgoData(def_data.value); + var factory_def_data = def_data.key.mode == AlgoKey.Mode.Factory ? def_data : AlgoData.from_custom_def(def_data.value); _algo_root = backing(nameof(algo_root), _algo_roots.GetOrAdd(factory_def_data.key, _ => OrderTypeVMFactory.create(factory_def_data))); _visible_algo_root = backing(nameof(visible_algo_root)); + // only composite/studio algos can change root + if (key.mode == AlgoKey.Mode.Factory || key.mode == AlgoKey.Mode.Dynamic) { + _algo_root.Changing += (oldval, newval) => + Log.assert(newval != null && newval.id == key); + } _can_redo = backing(nameof(can_redo), () => _edit_stack.get_can_redo(_version.value)); _can_undo = backing(nameof(can_undo), () => _edit_stack.get_can_undo(_version.value)); _can_redo.Changed += on_can_redo_changed; _can_undo.Changed += on_can_undo_changed; _refresh_on_local_changes = new DeferrableActionWrapper(on_local_changed); // load initial state - init_async(); - async void init_async() { - // visible_algo_root is selected_template.algo_root if user can add templates, otherwise algo_root - // - this behavior is configurable in 'AlgoStudioOptions' in UI.proto (01/28/2018) - if (_model.algo_model.templates_enabled()) { - resources.Add(_selected_template.observe_current(true).Subscribe(t => _visible_algo_root.set(t?.algo_root))); - } else { - resources.Add(_algo_root.observe_current(true).Subscribe(_visible_algo_root.set)); + // visible_algo_root is selected_template.algo_root if user can add templates, otherwise algo_root + // - this behavior is configurable in 'AlgoStudioOptions' in UI.proto (01/28/2018) + resources.Add(_algo_root.observe_current(true).Subscribe(_visible_algo_root.set)); + // set hooks/subscriptions + using (_refresh_on_local_changes.supress_execution()) { + resources.AddRange( + custom_badge_color.observe_nullable(true).Subscribe(v => Set(ref _badge_fill, (v ?? algo_root.safe_get_badge_color()).to_brush(), nameof(badge_fill))), + as_demuxer().subscribe_many(_refresh_on_local_changes.execute, nameof(this.name), nameof(abbreviation), nameof(badge_fill)), + _edit_pane_vs_model.add_source(VisualStateNames.BadgeSelector.GroupName, custom_badge_color.observe_nullable(true).Select(t => t.HasValue ? VisualStateNames.BadgeSelector.Active : VisualStateNames.BadgeSelector.Inactive)), + _edit_pane_vs_model.add_source(VisualStateNames.Abbreviation.GroupName, _abbreviation.observe_current(true).Select(a => string.IsNullOrEmpty(a) ? VisualStateNames.Abbreviation.Unpopulated : VisualStateNames.Abbreviation.Populated)), + _algo_root.observe_current(true).SubscribeEach(vm => + vm == null ? null : + Disposable.Create( + vm.subscribe_is_dirty().Subscribe(v => { + if (!v) { + _version.increment_version(); + _on_committed_changed(); + } + }), + vm.subscribe_definition().Subscribe(_ => _refresh_on_local_changes.execute()))), + ObservableAutoWrapper.connect_item_hooks(algo_roots, a => a as IDisposable ?? Disposable.empty, true), + Disposable.Create(() => { + _can_redo.Changed -= on_can_redo_changed; + _can_undo.Changed -= on_can_undo_changed; + })); + switch (key.mode) { + case AlgoKey.Mode.Persisted: + _metadata = new AlgoDefinitionMetadata(key); + resources.Add(model.algo_model.metadata_service.subscribe_metadata(key).OnDispatcher().Subscribe(_on_metadata)); + _edit_pane_vs_model.set_state(VisualStateNames.Name.GroupName, conf.can_modify_definition_name ? VisualStateNames.Name.Active : VisualStateNames.Name.CannotRenameDefinition); + break; + case AlgoKey.Mode.Factory: + _edit_pane_vs_model.set_state(VisualStateNames.Name.GroupName, VisualStateNames.Name.Inactive); + break; } - // init tree view item visual state - _tree_view_vs_model.set_state(VisualStateNames.TreeViewBadge.GroupName, conf.show_badges_in_tree_view ? VisualStateNames.TreeViewBadge.Active : VisualStateNames.TreeViewBadge.Inactive); - // set hooks/subscriptions - using (_refresh_on_local_changes.supress_execution()) { - resources.AddRange( - custom_badge_color.observe_nullable(true).Subscribe(v => Set(ref _badge_fill, (v ?? algo_root.safe_get_badge_color()).to_brush(), nameof(badge_fill))), - as_demuxer().subscribe_many(_refresh_on_local_changes.execute, nameof(this.name), nameof(abbreviation), nameof(badge_fill)), - _edit_pane_vs_model.add_source(VisualStateNames.BadgeSelector.GroupName, custom_badge_color.observe_nullable(true).Select(t => t.HasValue ? VisualStateNames.BadgeSelector.Active : VisualStateNames.BadgeSelector.Inactive)), - _edit_pane_vs_model.add_source(VisualStateNames.Abbreviation.GroupName, _abbreviation.observe_current(true).Select(a => string.IsNullOrEmpty(a) ? VisualStateNames.Abbreviation.Unpopulated : VisualStateNames.Abbreviation.Populated)), - _algo_root.observe_current(true).SubscribeEach(vm => - vm == null ? null : - Disposable.Create( - vm.subscribe_is_dirty().Subscribe(v => { - if (!v) { - _version.increment_version(); - _on_committed_changed(); - } - }), - vm.subscribe_definition().Subscribe(_ => _refresh_on_local_changes.execute()))), - ObservableAutoWrapper.connect_item_hooks(algo_roots, a => a as IDisposable ?? Disposable.empty, true), - ObservableAutoWrapper.connect_item_hooks(templates, t => new CompositeDisposable(_any_templates_dirty_monitor.join(t), t), true), - Disposable.Create(() => { - _can_redo.Changed -= on_can_redo_changed; - _can_undo.Changed -= on_can_undo_changed; - })); - switch (key.mode) { - case AlgoKey.Mode.Persisted: - _metadata = new AlgoDefinitionMetadata(key); - resources.Add(_template_update_buffer.OnDispatcher().Subscribe(_on_templates)); - resources.Add(model.algo_model.metadata_service.subscribe_metadata(key).OnDispatcher().Subscribe(_on_metadata)); - _edit_pane_vs_model.set_state(VisualStateNames.Name.GroupName, conf.can_modify_definition_name ? VisualStateNames.Name.Active : VisualStateNames.Name.CannotRenameDefinition); - break; - case AlgoKey.Mode.Factory: - _edit_pane_vs_model.set_state(VisualStateNames.Name.GroupName, VisualStateNames.Name.Inactive); - break; - } - var permission_src = _permissions_mask.observe_result(); - resources.Add(_selected_format.observe_current(true).CombineLatest(permission_src, (fmt, perms) => (fmt, perms)) - .SubscribeEach(t => { - if ((t.perms & AlgoEditingPermissions.AllowEditStructure) != 0) { - using (_refresh_on_local_changes.defer_execution()) { - var algo_data = model.factory.default_algos(t.fmt); - var default_algo = new AlgoKey(OrderDataHelper.get_default_algo(t.fmt)); - return this.load_algo_data_recursive(algo_data, default_algo); - } + var permission_src = _permissions_mask.observe_result(); + resources.Add(_selected_format.observe_current(true).CombineLatest(permission_src, (fmt, perms) => (fmt, perms)) + .SubscribeEach(t => { + if ((t.perms & AlgoEditingPermissions.AllowEditStructure) != 0) { + using (_refresh_on_local_changes.defer_execution()) { + var algo_data = model.factory.default_algos(t.fmt); + var default_algo = AlgoKey.from_known_type(OrderDataHelper.get_default_algo(t.fmt)); + return this.load_algo_data_recursive(algo_data, default_algo); } - return Disposable.empty; - })); - resources.Add(permission_src.Subscribe(_ => RaisePropertyChanged(nameof(editing_permissions)))); - resources.Add(this.connect_data(permission_src)); - resources.Add(this.connect_data(Observable.Return(model))); - resources.Add(_algo_root.Subscribe(_ => RaisePropertyChanged(nameof(IAlgoSelector.selected_algo), nameof(IAlgoParamVM.value), nameof(group)))); - _dispose = resources; - await algo_root.load_from_async(def_data.value); - _version.increment_version(); - _edit_stack.reset(_version.value); - _on_committed_changed(); - } + } + return Disposable.empty; + })); + resources.Add(permission_src.Subscribe(_ => RaisePropertyChanged(nameof(editing_permissions)))); + resources.Add(this.connect_data(permission_src)); + resources.Add(this.connect_data(Observable.Return(model))); + resources.Add(_algo_root.Subscribe(_ => RaisePropertyChanged(nameof(IAlgoSelector.selected_algo), nameof(IAlgoParamVM.value), nameof(group)))); + _dispose = resources; + algo_root.load_from(def_data.value); + _version.increment_version(); + _edit_stack.reset(_version.value); + _on_committed_changed(); } // local methods void on_can_redo_changed(bool oldval, bool newval) => can_redo_changed?.Invoke(); @@ -206,7 +175,6 @@ namespace mbts.spark { public IReadOnlyObservableCollection algos_view { get; } public IAlgoVM algo_root { get => _algo_root.Value; set => _algo_root.set(value); } public IAlgoVM visible_algo_root => _visible_algo_root.Value; - public AlgoDefinitionTemplateVM selected_template { get => _selected_template.Value; set => _selected_template.set(value); } public int? favorite_index { get => _favorite_index; set { @@ -219,34 +187,12 @@ namespace mbts.spark { public bool is_selected { get => _is_selected.Value; set => _is_selected.set(value); } public bool is_dirty => _is_dirty.Value; public bool is_factory_definition => key.mode == AlgoKey.Mode.Factory; - public AlgoDisplayGroup group { - get { - switch (key.mode) { - case AlgoKey.Mode.Factory: - if (algo_root != null) - return algo_root.group; - break; - case AlgoKey.Mode.Unpersisted: - case AlgoKey.Mode.Persisted: - return AlgoDisplayGroup.Studio; - } - return AlgoDisplayGroup.BTS; - } - } + public AlgoDisplayGroup group => key.display_group(); public bool can_redo => _can_redo.Value; public bool can_undo => _can_undo.Value; public EnabledValueVM custom_badge_color { get; } = new EnabledValueVM(); public ObservableCollection custom_badge_color_palettes { get; } = new ObservableCollection(); public Brush badge_fill => _badge_fill; - public ObservableCollection templates => _templates; - /// has the same elements as , plus the custom-placeholder-item, which is always at index 0. - /// The custom-placeholder supports legacy behavior in the ladder/ticket algo popup by allowing the user to manipulate the algo-structure (e.g. change an iceberg-limit order to iceberg-lean-cover-offset etc.). - /// However, the custom-placeholder item cannot be used to create/save algo-templates. - /// Algo-templates are just a set of values used to populate a concrete algo-structure; the 'structures' can be created in the AlgoStudio (). - /// If we were to strictly follow this paradigm, the user would no longer be able to freely change the algo-structure in the ladder/ticket popup (they would be forced to open up a new , and we know how much they hate more clicks!). - /// Some users might consider this a regression. The custom-placeholder-item addresses that concern. - public ObservableAppendCollection templates_with_custom => _templates_with_custom; - public ListCollectionView templates_view { get; } // format public AlgoFormats selected_format { get => _selected_format.Value; set => _selected_format.set(value); } public ObservableCollection formats { get; } = new ObservableCollection { AlgoFormats.Exchange, AlgoFormats.Spreader, AlgoFormats.Exchange | AlgoFormats.Spreader }; @@ -321,24 +267,7 @@ namespace mbts.spark { } } - // idempotent - public void prepend_custom_template() { - if (_templates_with_custom.appended_front.Count == 0) - _templates_with_custom.insert_front(new AlgoDefinitionTemplateVM.CustomTemplatePlaceholderVM(this, _model, algo_root.definition)); - } - - public AlgoDefinitionTemplateVM template_factory() => - new AlgoDefinitionTemplateVM(this, _model, algo_root.create_def_data().with(name: new_template_name)) { - is_selected = true - }; - public IObservable subscribe_is_definition_dirty() => _is_dirty.observe_current(true); - public IObservable subscribe_any_templates_dirty() => _any_templates_dirty_monitor; - public IObservable subscribe_is_definition_or_any_templates_dirty() => - Observable.Merge( - subscribe_is_definition_dirty().Select(v => v || _any_templates_dirty_monitor.is_above_threshold), - subscribe_any_templates_dirty().Select(v => v || is_dirty)) - .DistinctUntilChanged(); public void undo() => _restore(_edit_stack.try_undo); public void redo() => _restore(_edit_stack.try_redo); @@ -347,20 +276,9 @@ namespace mbts.spark { _assign_from_data(_committed.Value); _on_committed_changed(); } - /// - /// Subscribes to the templates source for this definition if it has been persisted (subscription requires a persistant id); does nothing if this definition has not been persisted, or if it is already subscribed (idempotent). - /// - public void connect() { - if (!_connected) { - _connected = true; - concat_disposable(_model.algo_model.subscribe_definition_templates(key).OnDispatcher().Subscribe(_template_update_buffer.OnNext)); - } - } - - public IDisposable buffer_updates() => _template_update_buffer.buffer_updates(); public void load_def(CustomOrderDefinitionImmutable def) { - var key = OrderDataHelper.get_shallow_factory_key(def); + var key = AlgoKey.from_custom_def(def); if (algo_root?.id == key) { algo_root.load_from(def); } else if (_algo_roots.TryGetValue(key, out IAlgoVM vm)) { @@ -384,7 +302,7 @@ namespace mbts.spark { case 1: load_def(def_list[0]); break; default: var def = def_list[0]; - var key = OrderDataHelper.get_shallow_factory_key(def); + var key = AlgoKey.from_custom_def(def); if (algo_root?.id == key) { algo_root.load_many(def_list); } else if (_algo_roots.TryGetValue(key, out IAlgoVM vm)) { @@ -414,7 +332,7 @@ namespace mbts.spark { new AlgoDefinitionVM(_model, def, selected_format, editing_permissions_mask); public AlgoData create_algo_def() => - new AlgoData(algo_root.definition, name, key); + AlgoData.create(algo_root == null ? new CustomOrderDefinitionImmutable(new CustomOrderDefinition()) : algo_root.definition, name, key); public AlgoDefinitionMetadata create_metadata() => _metadata.with(abbreviation: abbreviation, badge_color: new NullableColorProto(custom_badge_color.get_nullable())); @@ -443,7 +361,7 @@ namespace mbts.spark { void _assign_from_data(string name, CustomOrderDefinitionImmutable definition) { this.name = name; - algo_root = _algo_roots.GetOrAdd(OrderDataHelper.get_shallow_factory_key(definition), _ => _mk_algo_root(definition)); + algo_root = _algo_roots.GetOrAdd(AlgoKey.from_custom_def(definition), _ => _mk_algo_root(definition)); algo_root.load_from(definition); } @@ -458,18 +376,12 @@ namespace mbts.spark { public Snapshot current_value => _version.value; IAlgoVM _mk_algo_root(CustomOrderDefinitionImmutable definition) => - OrderTypeVMFactory.create(new AlgoData(definition), is_expanded: true); + OrderTypeVMFactory.create(AlgoData.from_custom_def(definition), is_expanded: true); void _on_metadata(AlgoDefinitionMetadata metadata) { using (_refresh_on_local_changes.supress_execution()) { _abbreviation.set(metadata.abbreviation); custom_badge_color.set_nullable(metadata.badge_color); - foreach (var t in templates) { - if (t.key.mode == AlgoKey.Mode.Persisted) - t.on_meta(t.key == metadata.default_template, metadata.favorite_templates.Contains(t.key)); - else - t.on_meta(false, false); - } _version.increment_version(); if (_edit_stack.size == 1 && _edit_stack.pos == 1) { // this is a hack to account for the metadata being part of the committed state, @@ -482,22 +394,6 @@ namespace mbts.spark { } } - void _on_templates(TableUpdate table) { - foreach (var rec in table.removed) - _templates.Remove(rec.key); - foreach (var rec in table.changed) - _templates[rec.key].load_from(rec); - foreach (var rec in table.added) { - if (_templates.TryGetValue(rec.key, out AlgoDefinitionTemplateVM tmp)) { - tmp.load_from(rec); - } else { - tmp = new AlgoDefinitionTemplateVM(this, _model, new AlgoData(rec.value, rec.name, rec.key)); - tmp.on_meta(tmp.key == _metadata.default_template, _metadata.favorite_templates.Contains(tmp.key)); - _templates.Add(tmp); - } - } - } - void _refresh_undo_redo() { _can_undo.refresh(); _can_redo.refresh(); diff --git a/src/client/spark/Modules/Trading/AlgoStudio/VM/AlgoStudioVM.cs b/src/client/spark/Modules/Trading/AlgoStudio/VM/AlgoStudioVM.cs index 3f08d209a..d2ff6af6b 100644 --- a/src/client/spark/Modules/Trading/AlgoStudio/VM/AlgoStudioVM.cs +++ b/src/client/spark/Modules/Trading/AlgoStudio/VM/AlgoStudioVM.cs @@ -1,6 +1,5 @@ using bts; using bts.api.orderman; -using bts.collections; using bts.utils; using mbts.collections; using mbts.ui; @@ -14,6 +13,7 @@ using System.Linq; using System.Reactive.Disposables; using System.Reactive.Linq; using System.Threading.Tasks; +using System.Windows; using System.Windows.Input; using StartupData = bts.shell.AlgoStudioWindowFactory.StartupData; @@ -37,29 +37,30 @@ namespace mbts.spark { }); } - class AlgoStudioVM : DisposableViewModelBase, IHandleSelectedItemChanged { + class AlgoStudioVM : DisposableViewModelBase { static readonly AlgoFormats _studio_formats = AlgoFormats.Exchange; readonly OrdersModel _model; readonly Property _selected_definition; - readonly Property _selected_template; readonly Property _editable_content; readonly DelegateProperty _save_cmd_tooltip, _revert_cmd_tooltip; readonly ObservableKeyedCollection _definitions = new ObservableKeyedCollection(d => d.key); readonly ListCollectionView _definitions_view; readonly TableUpdateBuffer _definitions_update_buffer; - readonly ReactiveThresholdMonitor _any_dirty_monitor = new ReactiveThresholdMonitor(d => d.subscribe_is_definition_or_any_templates_dirty()); + readonly ReactiveThresholdMonitor _any_dirty_monitor = new ReactiveThresholdMonitor(d => d.subscribe_is_definition_dirty()); IReadOnlyDictionary _persisted_meta = new Dictionary(); public AlgoStudioVM(OrdersModel model) { _model = model; _selected_definition = backing(nameof(selected_definition)); - _selected_template = backing(nameof(selected_template)); - _editable_content = backing(nameof(editable_content), observe_selected().SelectManyInSeries(tup => tup.template?.observe_algo_root() ?? tup.definition?.observe_algo_root()).OnDispatcher()); + _editable_content = backing(nameof(editable_content), subscribe_definition().SelectManyInSeries(def => def?.observe_algo_root()).OnDispatcher()); _definitions_update_buffer = new TableUpdateBuffer(def => def.key); _definitions_view = new ListCollectionView(definitions) { CustomSort = AlgoCollectionHelper.algo_definition_vm_comparer.to_non_generic() }; definitions_view.Filter = d => !(d.key.mode == AlgoKey.Mode.Persisted && _persisted_meta.TryGetValue(d.key, out AlgoDefinitionMetadata meta) && meta.is_hidden); + // add/clone + add_definition_cmd = new DelegateCommand(add_definition); + clone_selected_definition_cmd = new DelegateCommand(clone_selected_definition); // save var save_cmd = new ObservantAsyncCommand(save_async); this.save_cmd = save_cmd; @@ -71,13 +72,18 @@ namespace mbts.spark { // _dispose = new CompositeDisposable( _model.algo_model.definitions.Subscribe(_definitions_update_buffer), - _definitions_update_buffer.OnDispatcher().Subscribe(u => AlgoCollectionHelper.update_persisted_definitions(_definitions, u, d => AlgoDefinitionVM.create(model, d, true, _studio_formats))), + _definitions_update_buffer.OnDispatcher().Subscribe(u => { + var orig_selected_def = selected_definition; + AlgoCollectionHelper.update_persisted_definitions(_definitions, u, d => AlgoDefinitionVM.create(model, d, _studio_formats)); + if (selected_definition == null) + selected_definition = definitions.FirstOrDefault(); + }), _model.algo_model.metadata_service.subscribe_metadata().OnDispatcher().Subscribe(meta => { _persisted_meta = meta; definitions_view.Refresh(); }), - ObservableAutoWrapper.connect(observe_selected().Select(t => t.template?.edit_pane_visual_states ?? t.definition?.edit_pane_visual_states ?? new ObservableCollection()), content_visual_states), - observe_selected().SelectManyInSeries(t => t.template?.observe_is_dirty() ?? t.definition?.subscribe_is_definition_or_any_templates_dirty() ?? Observable.Return(false)).OnDispatcher() + ObservableAutoWrapper.connect(subscribe_definition().Select(def => def?.edit_pane_visual_states ?? new ObservableCollection()), content_visual_states), + subscribe_definition().SelectManyInSeries(def => def?.subscribe_is_definition_dirty() ?? Observable.Return(false)).OnDispatcher() .Subscribe(new CompositeObserver(save_cmd, revert_cmd) { val => { _save_cmd_tooltip.refresh(); _revert_cmd_tooltip.refresh(); @@ -85,77 +91,64 @@ namespace mbts.spark { ObservableAutoWrapper.connect_item_hooks(definitions, d => new CompositeDisposable(_any_dirty_monitor.join(d), d), true)); // local methods string get_revert_tooltip() { - if (content_source is AlgoDefinitionTemplateVM tmp) { - switch (tmp.key.mode) { - case AlgoKey.Mode.Persisted: return tmp.is_dirty ? $"Revert changes to '{tmp.name}'" : "No changes to revert"; - } - } else if (content_source is AlgoDefinitionVM def) { - switch (def.key.mode) { - case AlgoKey.Mode.Persisted: return def.is_dirty || def.templates.Any(t => t.is_dirty) ? $"Revert changes to '{def.name}' templates" : "No changes to revert"; - } - } - return null; + var def = selected_definition; + return def != null && def.key.mode == AlgoKey.Mode.Persisted ? + (def.is_dirty ? $"Revert changes to '{def.name}' templates" : "No changes to revert") : + null; } async Task save_async(IAlgoStudioContentVM content) { - if (content is AlgoDefinitionTemplateVM tmp) { - await save_template(tmp); - } else if (content is AlgoDefinitionVM def) { + if (content is AlgoDefinitionVM def) await save_definition(def); - } } string get_save_tooltip() { - if (content_source is AlgoDefinitionTemplateVM tmp) { - switch (tmp.key.mode) { - case AlgoKey.Mode.Unpersisted: return tmp.is_dirty ? $"Save '{tmp.name}'" : $"Cannot Save '{tmp.name}'"; - case AlgoKey.Mode.Persisted: return tmp.is_dirty ? $"Save changes to '{tmp.name}'" : "No changes to save"; - } - } else if (content_source is AlgoDefinitionVM def) { + var def = selected_definition; + if (def != null) { switch (def.key.mode) { - case AlgoKey.Mode.Unpersisted: return def.is_dirty || def.templates.Any(t => t.is_dirty) ? $"Save '{def.name}'" : $"Cannot Save '{def.name}'"; - case AlgoKey.Mode.Persisted: return def.is_dirty || def.templates.Any(t => t.is_dirty) ? $"Save changes to '{def.name}' templates" : "No changes to save"; + case AlgoKey.Mode.Unpersisted: return def.is_dirty ? $"Save '{def.name}'" : $"Cannot Save '{def.name}'"; + case AlgoKey.Mode.Persisted: return def.is_dirty ? $"Save changes to '{def.name}' templates" : "No changes to save"; } } return null; } + + void add_definition() => + add_definition_common(AlgoDefinitionVM.new_algo_def, AlgoDefinitionVM.new_algo_name); + + void clone_selected_definition() { + if (selected_definition == null || selected_definition.algo_root == null) { + add_definition(); + } else { + add_definition_common( + selected_definition.algo_root.definition, + string.IsNullOrEmpty(selected_definition.name) ? AlgoDefinitionVM.new_algo_name : $"{selected_definition.name} - Copy"); + } + } + + void add_definition_common(CustomOrderDefinitionImmutable def, string name) { + var new_def = AlgoDefinitionVM.create_placeholder(_model, def, name, _studio_formats); + _definitions.Add(new_def); + selected_definition = new_def; + request_view_focus_name?.Invoke(new_def); + } } - event Action<(AlgoDefinitionVM definition, AlgoDefinitionTemplateVM template)> _selected_changed; + public event Action request_view_focus_name; public ObservableCollection definitions => _definitions; public ObservableCollection content_visual_states { get; } = new ObservableCollection(); public AlgoDefinitionVM selected_definition { get => _selected_definition.Value; set => _selected_definition.set(value); } - public AlgoDefinitionTemplateVM selected_template { get => _selected_template.Value; set => _selected_template.set(value); } - public IAlgoStudioContentVM content_source => (IAlgoStudioContentVM)selected_template ?? selected_definition; public IAlgoVM editable_content => _editable_content.Value; public ICollectionView definitions_view => _definitions_view; + public ICommand add_definition_cmd { get; } + public ICommand clone_selected_definition_cmd { get; } public ICommand save_cmd { get; } public ICommand revert_cmd { get; } public string save_cmd_tooltip => _save_cmd_tooltip.Value; public string revert_cmd_tooltip => _revert_cmd_tooltip.Value; - public void add_new_definition() => - _add_new_definition(AlgoDefinitionVM.new_algo_def, AlgoDefinitionVM.new_algo_name); - - public void add_new_definition_clone(AlgoDefinitionVM src_definition) { - if (src_definition == null || src_definition.algo_root == null) { - add_new_definition(); - } else { - _add_new_definition(src_definition.algo_root.definition, string.IsNullOrEmpty(src_definition.name) ? AlgoDefinitionVM.new_algo_name : $"{src_definition.name} - Copy"); - } - } - - void _add_new_definition(CustomOrderDefinitionImmutable def, string name) => - _definitions.Add(AlgoDefinitionVM.create_placeholder(_model, def, name, _studio_formats)); - public StartupData create() => new StartupData(); public void load_from(StartupData state) { } public IObservable subscribe_definition() => _selected_definition.observe_current(true); - public IObservable subscribe_template() => _selected_template.observe_current(true); - public IObservable<(AlgoDefinitionVM definition, AlgoDefinitionTemplateVM template)> observe_selected() => - Observable.Create<(AlgoDefinitionVM definition, AlgoDefinitionTemplateVM template)>(o => { - _selected_changed += o.OnNext; - return Disposable.Create(() => _selected_changed -= o.OnNext); - }); public IObservable subscribe_dirty() => _any_dirty_monitor; public async Task remove_definition(AlgoDefinitionVM definition) { @@ -163,87 +156,43 @@ namespace mbts.spark { await _model.algo_model.remove_definition(definition.key); } else { // This is a new definition, which hasn't been saved/persisted yet. No need to call the server. - definition.templates.Clear(); definitions.Remove(definition); } } - public async Task remove_template(AlgoDefinitionTemplateVM template) { - if (template.key.mode == AlgoKey.Mode.Persisted) { - await _model.algo_model.remove_template(template.key); - } else { - // This is a new template, which hasn't been saved/persisted yet. No need to call the server. - template.owner.templates.Remove(template); - } - } + public Task save_definition(AlgoDefinitionVM definition) => + _save(new[] { definition }); - public async Task save_definition(AlgoDefinitionVM definition) { - using (_save_op()) { - var newly_persisted_keys = await AlgoPersistenceHelper.persist_definition(_model, _definitions, definition); - AlgoKey pkey; - switch (definition.key.mode) { - case AlgoKey.Mode.Unpersisted: - if (!newly_persisted_keys.TryGetValue(definition.key, out pkey)) - return; - break; - case AlgoKey.Mode.Persisted: - pkey = definition.key; - break; - default: return; - } - await _model.algo_model.metadata_service.update_metadata(pkey, _ => definition.create_metadata().with(id: pkey)); - } - } + public Task save_all() => + _save(definitions); - public async Task save_template(AlgoDefinitionTemplateVM template) { - using (_save_op()) - await AlgoPersistenceHelper.persist_template(_model, _definitions, template); - } - - public async Task save_all() => - await _save(definitions.WrapSelector(def => (def, def.templates.AsList()), t => t.def)); - - async Task _save(IList<(AlgoDefinitionVM definition, IList templates)> definition_templates) { - using (_save_op()) - await AlgoPersistenceHelper.persist(_model, definition_templates); - } - - IDisposable _save_op() { - int? def_index = selected_definition == null ? (int?)null : _definitions.IndexOf(selected_definition); - int? tmp_index = selected_template == null ? (int?)null : selected_definition.templates.IndexOf(selected_template); - return new CompositeDisposable(_definitions_update_buffer.buffer_updates()) { - () => { - if (def_index.HasValue) { - var def = _definitions[def_index.Value]; - if (tmp_index.HasValue) { - var tmp = def.templates[tmp_index.Value]; - tmp.is_selected = true; - } else def.is_selected = true; + async Task _save(IEnumerable definitions) { + var orig_selected = selected_definition; + var orig_selected_index = orig_selected == null ? -1 : this.definitions.IndexOf(orig_selected); + using (_definitions_update_buffer.buffer_updates()) { + var def_list = definitions as IList ?? definitions.ToList(); + await Task.WhenAll(definitions.Select(async d => { + var def = await _model.algo_model.save_definition(d.create_algo_def()); + if (def.HasValue) { + // don't forget to save metadata + await _model.algo_model.metadata_service.update_metadata(def.Value.key, _ => d.create_metadata().with(def.Value.key)); } - } - }; - } - - /// Despite the existence of these properties: , and , - /// still implements to update the properties that depend on the . - /// [John]I am going to Uganda in 3 days (today is 1/3/2019), and decided against removing this legacy-dependency at the last minute. - /// Fwiw, and are bound to . - /// They serve to prevent a quirky default behavior in TreeView: double clicking any TreeViewItem collapses the entire TreeView. - /// This behavior wasn't just quirky either, it actually conflicted with the double-click-to-set-template-as-default behavior. - /// (for details, ) - void IHandleSelectedItemChanged.on_selected_item_changed(object old_value, object new_value) { - if (new_value is AlgoDefinitionVM def) { - selected_definition = def; - selected_template = null; - } else if (new_value is AlgoDefinitionTemplateVM templ) { - selected_definition = templ.owner; - selected_template = templ; - } else { - selected_definition = null; - selected_template = null; + return def; + })).ContinueOnDispatcher(t => { + if (t.Status != TaskStatus.RanToCompletion) { + Log.Ui.debug_fatal($"Algo Studio error saving definitions: unexpected Task.Status '{t.Status}'."); + return; + } + var persisted_data = t.Result; + Log.assert(persisted_data.Length == def_list.Count); + for (int i = 0; i < persisted_data.Length; i++) { + if (!def_list[i].key.is_persisted && persisted_data[i].HasValue) + _definitions.Replace(def_list[i].key, def_list[i].to_persisted(persisted_data[i].Value)); + } + if (selected_definition != orig_selected && orig_selected_index >= 0 && orig_selected_index < this.definitions.Count) + selected_definition = this.definitions[orig_selected_index]; + }); } - _selected_changed?.Invoke((selected_definition, selected_template)); - RaisePropertyChanged(nameof(content_source)); } } } \ No newline at end of file diff --git a/src/client/spark/Modules/Trading/AlgoStudio/VM/AlgoVMWrapper.cs b/src/client/spark/Modules/Trading/AlgoStudio/VM/AlgoVMWrapper.cs index aa97940d2..f82bbdd02 100644 --- a/src/client/spark/Modules/Trading/AlgoStudio/VM/AlgoVMWrapper.cs +++ b/src/client/spark/Modules/Trading/AlgoStudio/VM/AlgoVMWrapper.cs @@ -109,7 +109,6 @@ namespace mbts.spark { public bool key_match(KeyEventArgs e) => _algo_root?.key_match(e) ?? false; public void load_from(CustomOrderDefinitionImmutable value) => _algo_root?.load_from(value); public void load_many(IEnumerable values) => _algo_root?.load_many(values); - public Task load_from_async(CustomOrderDefinitionImmutable definition) => _algo_root is IAlgoVM vm ? vm.load_from_async(definition) : Task.FromResult(null); void IAlgoVM.ensure_init() => _value?.algo_root?.ensure_init(); IDisposable _set_hooks(AlgoDefinitionVM vm) { diff --git a/src/client/spark/Modules/Trading/AlgoStudio/View/AlgoEditorGridView/AlgoEditorGridView.xaml b/src/client/spark/Modules/Trading/AlgoStudio/View/AlgoEditorGridView/AlgoEditorGridView.xaml index f74c7cb68..ff34c90e1 100644 --- a/src/client/spark/Modules/Trading/AlgoStudio/View/AlgoEditorGridView/AlgoEditorGridView.xaml +++ b/src/client/spark/Modules/Trading/AlgoStudio/View/AlgoEditorGridView/AlgoEditorGridView.xaml @@ -513,6 +513,7 @@ LegTuples="{Binding leg_tuples}" RemoveLegCommand="{Binding remove_leg}" ContractPickerModel="{Binding contract_picker_model}" + IsEnabled="{Binding IsReadOnly, RelativeSource={RelativeSource AncestorType=usp:AlgoEditorGridView}, Converter={StaticResource NotConverter}}" /> diff --git a/src/client/spark/Modules/Trading/Ladder/LadderSettings.cs b/src/client/spark/Modules/Trading/Ladder/LadderSettings.cs index 7fbb2fb55..6f2a442c4 100644 --- a/src/client/spark/Modules/Trading/Ladder/LadderSettings.cs +++ b/src/client/spark/Modules/Trading/Ladder/LadderSettings.cs @@ -196,7 +196,7 @@ namespace mbts.spark { public readonly int column_count; public LadderFavoriteAlgosSettings(AlgoKey[] favorite_algos, int column_count) - : this(ArrayHelper.safe_convert(favorite_algos, k => k.persisted), column_count) { } + : this(ArrayHelper.safe_convert(favorite_algos, k => new bts.persist.algo.AlgoPersistedKey(k.persisted)), column_count) { } LadderFavoriteAlgosSettings(bts.persist.algo.AlgoPersistedKey[] favorite_algos, int column_count) { _favorite_algos = favorite_algos; @@ -339,6 +339,7 @@ namespace mbts.spark { zoom_slider_visible = false, zoom_factor = _default_zoom_factor, net_change = NetChangeTerms.None, + mini_ob = new LadderMiniOrderBookSettings(bts.shell.orderbook.OrderBookStartupData.default_mini_grid.general), }; rv.row_height = LadderRender.measure_row_height(rv); return rv; diff --git a/src/client/spark/Modules/Trading/Ladder/LadderWindowFactory.cs b/src/client/spark/Modules/Trading/Ladder/LadderWindowFactory.cs index de31cd1c3..3ab614a21 100644 --- a/src/client/spark/Modules/Trading/Ladder/LadderWindowFactory.cs +++ b/src/client/spark/Modules/Trading/Ladder/LadderWindowFactory.cs @@ -1,10 +1,9 @@ -using bts.api; +using bts.api; using bts.md; using mbts; using mbts.config; using mbts.persist; using mbts.spark; -using mbts.spark.utilities; using mbts.ui; using mbts.ui.shell; using mbts.ui.spark; @@ -68,8 +67,7 @@ namespace bts.shell { // profile was deleted id = 0; } else { - var curr_profile = _fit_to_sec(result.value, vm.security.ContractCase); - if (!s.Equals(curr_profile)) { + if (!s.Equals(result.value)) { // ladder's settings diverged from the profile (this happens when the user changes settings outside of the settings dialog, such as column widths, left panel width, etc.) id = 0; } @@ -79,7 +77,7 @@ namespace bts.shell { } int _ladder_count = 0; - IShellWindow create_ladder_window(SecurityMD md, LadderSettings state_settings, uint settings_id = 0) { + IShellWindow create_ladder_window(SecurityMD md, LadderSettings last_value, uint settings_id = 0) { IDisposable active_settings_dialog = null; var thread_id = Interlocked.Increment(ref _ladder_count) % Environment.ProcessorCount; // on_shell_window_vm should behave like an event (do not set to null) @@ -95,12 +93,11 @@ namespace bts.shell { lp => lp.id, lp => new SettingsProfile(lp.id, lp.name, LadderSettings.sanitize(lp.value), lp.security_criteria))), (us, lps) => us.with(ladder_profiles: lps.Values.Select(lp => new LadderSettingsProfile(lp.id, lp.name, lp.value, lp.security_criteria)).ToArray())); - state_settings?.sanitize(); + last_value?.sanitize(); /// When settings are adjusted outside of the settings dialog, the vm should raise the event. /// In response to that event, 'needs_resync' is set to true. This causes 'last_value' to be refreshed when the next caller requests the latest settings /// (i.e., an IObserver subscribing to the settings_source, or the settings-dialog viewmodel). bool initialized = false, needs_resync = false; - LadderSettings last_value = fit_to_sec(state_settings); LadderVM vm = null; var settings_subject = new Subject(); var settings_source = Observable.Create(o => { @@ -113,7 +110,7 @@ namespace bts.shell { }); }); // vm - vm = LadderVM.create(_bus, model, last_value ?? _settings_hub.current.ladder, settings_source); + vm = LadderVM.create(_bus, model, LadderSettings.sanitize(last_value ?? _settings_hub.current.ladder), settings_source); vm.settings_invalidated += on_settings_invalidated; vm.order_properties_vm.open_algo_popup_on_select = _ladder_conf.open_algo_popup_on_select; vm.order_properties_vm.use_algo_param_grid = _ladder_conf.use_algo_param_grid; @@ -130,9 +127,6 @@ namespace bts.shell { lv.Resources[kv.Key] = kv.Value; return lv; // local methods - LadderSettings fit_to_sec(LadderSettings s) => - _fit_to_sec(s, md.security.ContractCase); - void on_settings_invalidated() => needs_resync = true; @@ -159,7 +153,7 @@ namespace bts.shell { if (!last_value.Equals(vm.get_save_state())) { settings_id = 0; } else { - settings_subject.OnNext(last_value = fit_to_sec(profile.value)); + settings_subject.OnNext(last_value = profile.value); } } else { // profile was deleted; keep the current settings and switch to the 'Local' profile. @@ -169,7 +163,7 @@ namespace bts.shell { initialized = true; if (settings_id != 0) { if (us.ladder_profiles.TryGetFirst(p => p.id == settings_id, out var profile)) { - last_value = fit_to_sec(profile.value); + last_value = profile.value; } else { settings_id = 0; } @@ -179,13 +173,13 @@ namespace bts.shell { // TODO: Use a kind of 'match priority' to resolve conflicts when the security is included in more than 1 profile's security criteria. // In the meantime, simply use the first match. if (lp.security_criteria.includes(md.security)) { - last_value = fit_to_sec(lp.value); + last_value = lp.value; settings_id = lp.id; break; } } if (last_value == null) - last_value = fit_to_sec(_settings_hub.current.ladder); + last_value = _settings_hub.current.ladder; } settings_subject.OnNext(last_value); } @@ -201,7 +195,7 @@ namespace bts.shell { svm.load(s); return svm; }, - fit_to_sec, + _ => _, vm.get_save_state(), UserSettings.FileExtensions.LADDER, settings_id); @@ -283,20 +277,6 @@ namespace bts.shell { } } - LadderSettings _fit_to_sec(LadderSettings s, Security.ContractOneofCase sec_type) { - if (s == null) return null; - var algo_key = AlgoID.to_algo_key(s.default_algo, _orders_model.dynamic_helper.dynamic_type_index); - if (algo_key.mode == AlgoKey.Mode.Factory) { - var fitted_algo = OrderDataHelper.fit_to_type(algo_key.factory.structure.build_algo(_orders_model.dynamic_helper), sec_type, true); - if (fitted_algo.HasValue) { - // be sure to clone ('s' may be shared) - s = SparkUtils.clone_proto(s); - s.default_algo = AlgoID.from_custom_def(fitted_algo.Value); - } - } - return s; - } - readonly struct LadderConfig { public readonly uint max_open_ladders; public readonly bool ladders_on_threads, open_algo_popup_on_select, use_algo_param_grid; diff --git a/src/client/spark/Modules/Trading/Ladder/VM/LadderOrderVM.cs b/src/client/spark/Modules/Trading/Ladder/VM/LadderOrderVM.cs index ea503904d..60f1ea13a 100644 --- a/src/client/spark/Modules/Trading/Ladder/VM/LadderOrderVM.cs +++ b/src/client/spark/Modules/Trading/Ladder/VM/LadderOrderVM.cs @@ -35,7 +35,7 @@ namespace mbts.spark { readonly IBus _bus; readonly Property _font_family; readonly Property _font_weight; - readonly Property _font_size; + readonly Property _font_size, _grid_row_height; readonly Property _foreground, _background, _hoverbackground, _border; readonly Property _has_multiple_orders_at_same_level, _is_hedge_order; readonly Property _algo_type; @@ -64,6 +64,7 @@ namespace mbts.spark { _font_weight = backing(nameof(font_weight), owner.settings, get_font_weight, get_font_weight(fs)); _font_size = backing(nameof(font_size), owner.settings, get_font_size, get_font_size(fs)); _foreground = backing(nameof(foreground), owner.settings, get_foreground, get_foreground(fs)); + _grid_row_height = backing(nameof(grid_row_height), owner.settings, get_row_height, get_row_height(fs)); _background = backing(nameof(background), _color_bg_brush); _hoverbackground = backing(nameof(hoverbackground), _color_bg_brush); _border = backing(nameof(border), _color_bg_brush); @@ -75,6 +76,7 @@ namespace mbts.spark { FontWeight get_font_weight(LadderSettings s) => ui.utility.text.TextUtils.from_open_type_weight_safe(s.orders_column.font_weight); double get_font_size(LadderSettings s) => s.orders_column.font_size; Brush get_foreground(LadderSettings s) => s.orders_column.foreground.rgb_brush(); + double get_row_height(LadderSettings s) => s.row_height; // add_order(op); @@ -246,6 +248,7 @@ namespace mbts.spark { public FontFamily font_family => _font_family.Value; public FontWeight font_weight => _font_weight.Value; public double font_size => _font_size.Value; + public double grid_row_height => _grid_row_height.Value; public Brush foreground => _foreground.Value; public Brush background { get => _background.Value; private set => _background.Value = value; } public Brush hoverbackground { get => _hoverbackground.Value; private set => _hoverbackground.Value = value; } diff --git a/src/client/spark/Modules/Trading/Ladder/VM/LadderSettingsVM.cs b/src/client/spark/Modules/Trading/Ladder/VM/LadderSettingsVM.cs index ea67bad1d..d7847884f 100644 --- a/src/client/spark/Modules/Trading/Ladder/VM/LadderSettingsVM.cs +++ b/src/client/spark/Modules/Trading/Ladder/VM/LadderSettingsVM.cs @@ -136,7 +136,7 @@ namespace mbts.spark { c.PropertyChanged -= on_prop_changed; } AccountTuple? account_factory(KeyValuePair kv) => new AccountTuple(kv.Key, kv.Value); - AlgoDefinitionVM algo_factory(AlgoData data) => AlgoDefinitionVM.create(_model, data, false); + AlgoDefinitionVM algo_factory(AlgoData data) => AlgoDefinitionVM.create(_model, data); } public event Action result_changed; @@ -363,7 +363,9 @@ namespace mbts.spark { } else { clone = SparkUtils.clone_proto(_current); #pragma warning disable CS0612 // Type or member is obsolete - clone.mini_ob = new LadderMiniOrderBookSettings(mini_ob.create().with(sorting_criterion: _current.mini_ob.value.sorting_criterion)); + clone.mini_ob = new LadderMiniOrderBookSettings(_current.mini_ob.value != null ? + mini_ob.create().with(sorting_criterion: _current.mini_ob.value.sorting_criterion) : + mini_ob.create()); #pragma warning restore CS0612 // Type or member is obsolete } clone.badge_style = badge_style; @@ -394,7 +396,7 @@ namespace mbts.spark { clone.default_account = default_account.Value.id; // - algo clone.default_algo = default_algo != null ? - AlgoID.from_algo_key(default_algo.key, _model.dynamic_helper.dynamic_type_index) : + AlgoID.from_algo_key(default_algo.key) : (_desired_algo ?? LadderSettings.Default.default_algo); // - components clone.auto_clear = auto_clear; @@ -451,7 +453,7 @@ namespace mbts.spark { } void _try_select_desired_algo(bool bypass_setter = false) { - if (_desired_algo.HasValue && (!_default_algo.setter_called || bypass_setter) && _algo_definitions.TryGetValue(AlgoID.to_algo_key(_desired_algo.Value, _model.dynamic_helper.dynamic_type_index), out var vm)) { + if (_desired_algo.HasValue && (!_default_algo.setter_called || bypass_setter) && _algo_definitions.TryGetValue(AlgoID.to_algo_key(_desired_algo.Value), out var vm)) { _desired_algo = null; _default_algo.bypass_setter(vm); } diff --git a/src/client/spark/Modules/Trading/Ladder/VM/LadderVM.cs b/src/client/spark/Modules/Trading/Ladder/VM/LadderVM.cs index 006fc8f67..506835d9c 100644 --- a/src/client/spark/Modules/Trading/Ladder/VM/LadderVM.cs +++ b/src/client/spark/Modules/Trading/Ladder/VM/LadderVM.cs @@ -377,7 +377,7 @@ namespace mbts.spark { if (order_properties_vm.selected_account.HasValue) rv.default_account = order_properties_vm.selected_account.Value.id; if (order_properties_vm.selected_algo_definition != null) - rv.default_algo = AlgoID.from_algo_key(order_properties_vm.selected_algo_definition.key, _model.order_gateway.dynamic_helper.dynamic_type_index); + rv.default_algo = AlgoID.from_algo_key(order_properties_vm.selected_algo_definition.key); } return rv; } diff --git a/src/client/spark/Modules/Trading/Ladder/VM/LadderVMContainer.cs b/src/client/spark/Modules/Trading/Ladder/VM/LadderVMContainer.cs index dadd8123d..b50b9a890 100644 --- a/src/client/spark/Modules/Trading/Ladder/VM/LadderVMContainer.cs +++ b/src/client/spark/Modules/Trading/Ladder/VM/LadderVMContainer.cs @@ -51,7 +51,7 @@ namespace mbts.spark { LadderVM.create_readonly(_bus, new LadderModel(security_md.Value, _model, _model.mbo_service, new Func(osec => _selected_order_tree.Contains(osec.order.Key))), - Observable.Return(LadderSettings.Default)) : null); + Observable.Return(LadderSettings.sanitize(LadderSettings.Default))) : null); RaisePropertyChanged(nameof(value)); } } diff --git a/src/client/spark/Modules/Trading/Ladder/View/LadderGridHost.cs b/src/client/spark/Modules/Trading/Ladder/View/LadderGridHost.cs index 2a2af3223..b78519f62 100644 --- a/src/client/spark/Modules/Trading/Ladder/View/LadderGridHost.cs +++ b/src/client/spark/Modules/Trading/Ladder/View/LadderGridHost.cs @@ -694,12 +694,14 @@ namespace mbts.spark { // At any rate, we need this part hiding the tooltip so that we don't leave random tooltips around // and we have to reset to old row so that when we go back to what could be our preivous row, the tooltip gets drawn again //System.Diagnostics.Debug.WriteLine(" Tooltip - Volume is 0"); + _old_tooltip_row = int.MaxValue; _hide_tool_tip(); //_old_tooltip_row = Int32.MaxValue; } } } else { //System.Diagnostics.Debug.WriteLine(" Tooltip - not over Volume column"); + _old_tooltip_row = int.MaxValue; _hide_tool_tip(); } } diff --git a/src/client/spark/Modules/Trading/Ladder/View/LadderRender.cs b/src/client/spark/Modules/Trading/Ladder/View/LadderRender.cs index 8f0168332..d12c79a6c 100644 --- a/src/client/spark/Modules/Trading/Ladder/View/LadderRender.cs +++ b/src/client/spark/Modules/Trading/Ladder/View/LadderRender.cs @@ -215,16 +215,16 @@ namespace mbts.spark { Brush total_brush = null; if (settings.total.bars.result.HasValue) { total_brush = new SolidColorBrush(settings.total.bars.result.Value); - } else if (components.Count == 0) { + } else if (components.Count == 0 && !settings.show_ltq) { _clear_visual(dv); return; } // inflate the max so that the graph never fills the available space double max = data.Max(v => v.Volume) * 1.1; - Brush text_brush = settings.general.foreground.rgb_brush(); _render_cells(dv, row_height, data.Select(d => (d.Price, d)), settings.general, prices, spec, render_cell); /// local methods void render_cell(DrawingContext dc, int r, VolumeAtPriceLevelImmutable vap) { + Brush text_brush = settings.general.foreground.rgb_brush(); double y = row_height * r; var last_trade_here = r == last_index; @@ -259,6 +259,7 @@ namespace mbts.spark { if (settings.show_ltq && last_trade_here) { numbers_text.Clear(); numbers_text.Add(last_size_and_direction); + text_brush = BTSCoreColors.white; } if (numbers_text.Count > 0) { string str = string.Join("/", numbers_text); diff --git a/src/client/spark/Modules/Trading/Ladder/View/LadderView.xaml b/src/client/spark/Modules/Trading/Ladder/View/LadderView.xaml index c85b5ab34..f6dd7a8d4 100644 --- a/src/client/spark/Modules/Trading/Ladder/View/LadderView.xaml +++ b/src/client/spark/Modules/Trading/Ladder/View/LadderView.xaml @@ -39,6 +39,8 @@ + + - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/client/spark/view/Controls/Order/AlgoContentTemplateSelector.xaml.cs b/src/client/spark/view/Controls/Order/AlgoContentTemplateSelector.xaml.cs index a7af0cd77..73fe499a2 100644 --- a/src/client/spark/view/Controls/Order/AlgoContentTemplateSelector.xaml.cs +++ b/src/client/spark/view/Controls/Order/AlgoContentTemplateSelector.xaml.cs @@ -9,13 +9,11 @@ namespace mbts.ui.spark { class AlgoContentTemplateSelector : DataTemplateSelector { public const string DefinitionDropDownStyleKey = nameof(DefinitionDropDownStyleKey), - TemplateDropDownStyleKey = nameof(TemplateDropDownStyleKey), TriggerTimeoutEnabledStateName = nameof(TriggerTimeoutEnabledStateName); public static readonly IValueConverter AlgoDropDownStyleKeyConverter = ValueConverter.create(obj => { - if (obj is AlgoDefinitionTemplateVM t) return TemplateDropDownStyleKey; - if (obj is AlgoDefinitionVM d) return DefinitionDropDownStyleKey; + if (obj is AlgoDefinitionVM) return DefinitionDropDownStyleKey; return null; }), DataContextConverter = ValueConverter.create(obj => obj is AlgoVMWrapper w ? w.value.algo_root : obj); @@ -43,8 +41,10 @@ namespace mbts.ui.spark { public DataTemplate GLBXIcebergOrderTemplate { get; set; } public DataTemplate IcebergOrderTemplate { get; set; } public DataTemplate SpreaderTemplate { get; set; } + public DataTemplate SplitterTemplate { get; set; } public DataTemplate DynamicOrderTemplate { get; set; } public DataTemplate DefaultOrderTemplate { get; set; } + public DataTemplate GenericOrderTemplate { get; set; } public override DataTemplate SelectTemplate(object item, DependencyObject container) { if (item is IDynamicAlgoVMImpl) { @@ -66,7 +66,9 @@ namespace mbts.ui.spark { case CustomOrderDefinition.CustomOneofCase.GlbxIceberg: return GLBXIcebergOrderTemplate; case CustomOrderDefinition.CustomOneofCase.Iceberg: return IcebergOrderTemplate; case CustomOrderDefinition.CustomOneofCase.Spreader: return SpreaderTemplate; + case CustomOrderDefinition.CustomOneofCase.Splitter: return SplitterTemplate; case CustomOrderDefinition.CustomOneofCase.Dynamic: return DynamicOrderTemplate; + default: return GenericOrderTemplate; } } return null; diff --git a/src/client/spark/view/Controls/Order/AlgoPickerNodeView.xaml.cs b/src/client/spark/view/Controls/Order/AlgoPickerNodeView.xaml.cs index 0e7b584b7..f346cad57 100644 --- a/src/client/spark/view/Controls/Order/AlgoPickerNodeView.xaml.cs +++ b/src/client/spark/view/Controls/Order/AlgoPickerNodeView.xaml.cs @@ -137,7 +137,7 @@ namespace mbts.ui.spark.algo { #region DropDownStyleKey public static readonly DependencyProperty DropDownStyleKeyProperty = - WPFHelper.create_dp(nameof(DropDownStyleKey), AlgoContentTemplateSelector.TemplateDropDownStyleKey); + WPFHelper.create_dp(nameof(DropDownStyleKey), AlgoContentTemplateSelector.DefinitionDropDownStyleKey); public object DropDownStyleKey { get => GetValue(DropDownStyleKeyProperty); diff --git a/src/client/spark/view/Controls/Order/AlgoTemplateFavoriteButtonsView.xaml b/src/client/spark/view/Controls/Order/AlgoTemplateFavoriteButtonsView.xaml index b1f1a5bd9..fb026d8f0 100644 --- a/src/client/spark/view/Controls/Order/AlgoTemplateFavoriteButtonsView.xaml +++ b/src/client/spark/view/Controls/Order/AlgoTemplateFavoriteButtonsView.xaml @@ -76,59 +76,17 @@ x:Name="PART_AlgoTemplateToolBar" Margin="{StaticResource Margin.LP1}" MinWidth="230" - ShowRenameDefinition="{DynamicResource {x:Static sp:AlgoStudioWindow.ShowAlgoToolBarRenameDefinitionKey}}" ShowSaveDefinition="{DynamicResource {x:Static sp:AlgoStudioWindow.ShowAlgoToolBarSaveDefinitionKey}}" - ShowTemplatesDropDown="{DynamicResource {x:Static sp:AlgoStudioWindow.TemplatesEnabledKey}}" Definition="{Binding DataContext, RelativeSource={RelativeSource AncestorType=ListBoxItem}}" - EditableCollectionModel="{Binding algo_template_collection_model}" Padding="0,1,0,3" - RemoveCommand="{Binding remove_template_cmd}" - UndoCommand="{Binding undo_cmd}" - RedoCommand="{Binding redo_cmd}" UndoDefinitionCommand="{Binding undo_definition_cmd}" RedoDefinitionCommand="{Binding redo_definition_cmd}" ShowUndoRedoButtons="{DynamicResource {x:Static sp:AlgoStudioWindow.ShowAlgoToolBarUndoRedoDefinitionKey}}" SetDefaultsCommand="{Binding set_default_algo_params_cmd}" RevertDefinitionCommand="{Binding revert_algo_params_cmd}" ShowRevertDefinition="{DynamicResource {x:Static sp:AlgoStudioWindow.ShowAlgoToolBarRevertDefinitionKey}}" - SaveCommand="{Binding save_template_cmd}" SaveDefinitionCommand="{Binding save_definition_cmd}" - ToggleFavoriteCommand="{Binding toggle_favorite_cmd}" - SelectedItem="{Binding selected_algo_template, Mode=TwoWay}" - ItemContainerStyle="{StaticResource AlgoTemplateItemContainerStyle}" - > - - - - - - - - -