示例#1
0
        private async Task <bool> IsStrategyRunningAsync()
        {
            try
            {
                if (!IsValidSelectServer())
                {
                    return(false);
                }

                var strategyParameters = new InterfaceStrategy.StrategyParameters {
                    StrategyName = Strategy.Name
                };
                var strategyParametersJson = JsonConvert.SerializeObject(strategyParameters);

                var strategyRunnerClient = new InterfaceStrategy.StrategyRunnerClient();

                var response = await strategyRunnerClient.PostAsync($"{SelectedServer.Url}/isstrategyrunning", strategyParametersJson);

                var content = await response.Content.ReadAsStringAsync();

                if (response.StatusCode == System.Net.HttpStatusCode.OK)
                {
                    return(content.Equals("YES"));
                }
                else
                {
                    ViewModelContext.UiDispatcher.Invoke(() =>
                    {
                        NotificationsAdd(
                            new Message
                        {
                            MessageType = response.StatusCode == System.Net.HttpStatusCode.OK ? MessageType.Info : MessageType.Error,
                            Text        = response.StatusCode.ToString(),
                            TextVerbose = JsonConvert.SerializeObject(content, Formatting.Indented)
                        });
                    });
                }
            }
            catch (Exception ex)
            {
                Logger.Log($"IsStrategyRunningAsync {ex.ToString()}", Prism.Logging.Category.Exception, Prism.Logging.Priority.High);

                NotificationsAdd(new Message {
                    MessageType = MessageType.Error, Text = $"Unable to connect to the remote server.", TextVerbose = ex.ToString()
                });
            }

            return(false);
        }
示例#2
0
        private async Task RunAsync()
        {
            try
            {
                if (!IsValidSelectServer())
                {
                    return;
                }

                var result = await MonitorAsync(true);

                if (result)
                {
                    await SetCommandVisibility(false, false, true);

                    var interfaceStrategy = Strategy.ToInterfaceStrategy();
                    var jsonContent       = JsonConvert.SerializeObject(interfaceStrategy);

                    var dependencies = strategy.Dependencies.Select(d => d.File);

                    var strategyRunnerClient = new InterfaceStrategy.StrategyRunnerClient();

                    var response = await strategyRunnerClient.PostAsync($"{SelectedServer.Url}/runstrategy", jsonContent, dependencies);

                    if (response.StatusCode != System.Net.HttpStatusCode.OK)
                    {
                        await SetCommandVisibility(false, false, false);

                        await DisconnectSocketAsync();
                    }
                    else
                    {
                        var accountBalances = AccountViewModel.Account.AccountInfo.Balances.ToList();

                        await SetCommandVisibility(false, false, true);
                    }

                    var content = JsonConvert.DeserializeObject(await response.Content.ReadAsStringAsync());

                    ViewModelContext.UiDispatcher.Invoke(() =>
                    {
                        NotificationsAdd(
                            new Message
                        {
                            MessageType = response.StatusCode == System.Net.HttpStatusCode.OK ? MessageType.Info : MessageType.Error,
                            Text        = response.StatusCode.ToString(),
                            TextVerbose = JsonConvert.SerializeObject(content, Formatting.Indented)
                        });
                    });
                }
            }
            catch (Exception ex)
            {
                Logger.Log($"RunAsync {ex.Message}", Prism.Logging.Category.Exception, Prism.Logging.Priority.High);

                NotificationsAdd(new Message {
                    MessageType = MessageType.Error, Text = $"Run - {ex.Message}", TextVerbose = ex.ToString()
                });
                await SetCommandVisibility(false, false, false);
                await DisconnectSocketAsync();
            }
        }