public SettingsViewModel Settings()
{
ICoreService coreService = Application.Resolve <ICoreService>();
ITradingService tradingService = Application.Resolve <ITradingService>();
IEnumerable <IConfigurableService> allConfigurableServices = Application.Resolve <IEnumerable <IConfigurableService> >();
var model = new SettingsViewModel()
{
InstanceName = coreService.Config.InstanceName,
Version = coreService.Version,
ReadOnlyMode = coreService.Config.ReadOnlyMode,
BuyEnabled = tradingService.Config.BuyEnabled,
BuyDCAEnabled = tradingService.Config.BuyDCAEnabled,
SellEnabled = tradingService.Config.SellEnabled,
TradingSuspended = tradingService.IsTradingSuspended,
HealthCheckEnabled = coreService.Config.HealthCheckEnabled,
Configs = allConfigurableServices
.Where(s => !s.GetType().Name.Contains(Constants.ServiceNames.BacktestingService))
.OrderBy(s => s.ServiceName)
.ToDictionary(s => s.ServiceName, s => Application.ConfigProvider.GetSectionJson(s.ServiceName))
};
return(model);
}
public SettingsViewModel Settings(SaveSettingsRequest model)
{
if (!Application.Resolve <ICoreService>().Config.ReadOnlyMode)
{
ICoreService coreService = Application.Resolve <ICoreService>();
ITradingService tradingService = Application.Resolve <ITradingService>();
coreService.Config.HealthCheckEnabled = model.HealthCheckEnabled;
tradingService.Config.BuyEnabled = model.BuyEnabled;
tradingService.Config.BuyDCAEnabled = model.BuyDCAEnabled;
tradingService.Config.SellEnabled = model.SellEnabled;
if (model.TradingSuspended)
{
tradingService.SuspendTrading();
}
else
{
tradingService.ResumeTrading();
}
return(this.Settings());
}
else
{
return(this.Settings());
}
}
public SignalsService(ILoggingService loggingService, IHealthCheckService healthCheckService, ITradingService tradingService, IRulesService rulesService)
{
this.loggingService = loggingService;
this.healthCheckService = healthCheckService;
this.tradingService = tradingService;
this.rulesService = rulesService;
}
public override void Save()
{
lock (this.SyncRoot)
{
try
{
ITradingService tradingService = Application.Resolve <ITradingService>();
string accountFilePath = Path.Combine(Directory.GetCurrentDirectory(), tradingService.Config.AccountFilePath);
var data = new TradingAccountData
{
Balance = balance,
TradingPairs = tradingPairs,
};
string accountJson = JsonConvert.SerializeObject(data, Formatting.Indented);
var accountFile = new FileInfo(accountFilePath);
accountFile.Directory.Create();
File.WriteAllText(accountFile.FullName, accountJson);
}
catch (Exception ex)
{
loggingService.Error("Unable to save account data", ex);
}
}
}
public IActionResult BuyDefault(BuyRequest buyRequest)
{
if (Application.Resolve <ICoreService>().Config.ReadOnlyMode)
{
return(new BadRequestResult());
}
if (!string.IsNullOrWhiteSpace(buyRequest.Pair))
{
ISignalsService signalsService = Application.Resolve <ISignalsService>();
ITradingService tradingService = Application.Resolve <ITradingService>();
tradingService.Buy(new BuyOptions(buyRequest.Pair)
{
MaxCost = tradingService.GetPairConfig(buyRequest.Pair).BuyMaxCost,
IgnoreExisting = true,
ManualOrder = true,
Metadata = new OrderMetadata
{
BoughtGlobalRating = signalsService.GetGlobalRating()
}
});
return(new OkResult());
}
else
{
return(new BadRequestResult());
}
}
public ConfigController(FakeExchangeConnectorSettings fakeExchangeConnectorSettings,
ITradingService tradingService)
{
_fakeExchangeConnectorSettings = fakeExchangeConnectorSettings;
_tradingService = tradingService;
}
private TradingAccountData LoadSavedData()
{
lock (this.SyncRoot)
{
try
{
ITradingService tradingService = Application.Resolve <ITradingService>();
string accountFilePath = Path.Combine(Directory.GetCurrentDirectory(), tradingService.Config.AccountFilePath);
if (File.Exists(accountFilePath))
{
this.BackupAccountData(accountFilePath);
string accountJson = File.ReadAllText(accountFilePath);
return(JsonConvert.DeserializeObject <TradingAccountData>(accountJson));
}
else
{
return(null);
}
}
catch (Exception ex)
{
loggingService.Error("Unable to load account data", ex);
return(null);
}
}
}
public BacktestingSaveSnapshotsTimedTask(ILoggingService loggingService, IHealthCheckService healthCheckService, ITradingService tradingService, ISignalsService signalsService, IBacktestingService backtestingService)
{
this.loggingService = loggingService;
this.healthCheckService = healthCheckService;
this.tradingService = tradingService;
this.signalsService = signalsService;
this.backtestingService = backtestingService;
}
public TradingAccountBase(ILoggingService loggingService, INotificationService notificationService, IHealthCheckService healthCheckService, ISignalsService signalsService, ITradingService tradingService)
{
this.loggingService = loggingService;
this.notificationService = notificationService;
this.healthCheckService = healthCheckService;
this.signalsService = signalsService;
this.tradingService = tradingService;
}
public OrdersController(IExchangeCache exchangeCache,
ITradingService tradingService,
IQuoteService quoteService)
{
_exchangeCache = exchangeCache;
_tradingService = tradingService;
_quoteService = quoteService;
}
public HealthCheckTimedTask(ILoggingService loggingService, INotificationService notificationService, IHealthCheckService healthCheckService, ICoreService coreService, ITradingService tradingService)
{
this.loggingService = loggingService;
this.notificationService = notificationService;
this.healthCheckService = healthCheckService;
this.coreService = coreService;
this.tradingService = tradingService;
}
public SignalRulesTimedTask(ILoggingService loggingService, IHealthCheckService healthCheckService, ITradingService tradingService, IRulesService rulesService, ISignalsService signalsService)
{
this.loggingService = loggingService;
this.healthCheckService = healthCheckService;
this.tradingService = tradingService;
this.rulesService = rulesService;
this.signalsService = signalsService;
}
public TestController(UserManager <AppUser> userManager, DataContext dataContext, ITradingService tradingService,
IMapper mapper)
{
_userManager = userManager;
_dataContext = dataContext;
_tradingService = tradingService;
_mapper = mapper;
}
public Rule(
ISymbolRepository symbolRepository,
ITradingService executionService,
IQueryService queryService)
{
_symbolRepository = symbolRepository;
_executionService = executionService;
_queryService = queryService;
}
public BacktestingSignalsService(ILoggingService loggingService, IHealthCheckService healthCheckService, ITasksService tasksService, ITradingService tradingService, IRulesService rulesService, IBacktestingService backtestingService)
{
this.loggingService = loggingService;
this.healthCheckService = healthCheckService;
this.tasksService = tasksService;
this.tradingService = tradingService;
this.rulesService = rulesService;
this.backtestingService = backtestingService;
}
public BacktestingLoadSnapshotsTimedTask(ILoggingService loggingService, IHealthCheckService healthCheckService, ITradingService tradingService, IBacktestingService backtestingService)
{
this.loggingService = loggingService;
this.healthCheckService = healthCheckService;
this.tradingService = tradingService;
this.backtestingService = backtestingService;
PopulateSnapshotPaths();
}
public MainMenuViewModel(ITradingService tradingService)
{
_tradingService = tradingService;
Title = "Main menu";
SelectOptionsCommand = new RelayCommand(SelectOptions);
SelectMarketCommand = new RelayCommand <string>(SelectMarket);
}
public OptionsSimulatorViewModel(ITradingService tradingService)
{
_tradingService = tradingService;
Title = "Options simulation";
GoBackCommand = new RelayCommand(GoBack);
UpdateCommand = new RelayCommand(Update);
ResetCommand = new RelayCommand(Reset);
}
public TradingTimedTask(ILoggingService loggingService, INotificationService notificationService,
IHealthCheckService healthCheckService, ISignalsService signalsService, IOrderingService orderingService, ITradingService tradingService)
{
this.loggingService = loggingService;
this.notificationService = notificationService;
this.healthCheckService = healthCheckService;
this.signalsService = signalsService;
this.orderingService = orderingService;
this.tradingService = tradingService;
}
public MarketViewModel(MainViewModel mainViewModel, string epic)
{
_mainViewModel = mainViewModel;
_tradingService = ServiceLocator.Current.GetInstance <ITradingService>();
_settingsService = ServiceLocator.Current.GetInstance <ISettingsService>();
_marketEpic = epic;
KeyPressCommand = new RelayCommand <Key>(KeyPress);
}
public TradingViewCryptoSignalReceiver(string signalName, IConfigurationSection configuration,
ILoggingService loggingService, IHealthCheckService healthCheckService, ISignalsService signalsService, ITradingService tradingService)
{
this.SignalName = signalName;
this.Config = configuration.Get <TradingViewCryptoSignalReceiverConfig>();
this.loggingService = loggingService;
this.healthCheckService = healthCheckService;
this.signalsService = signalsService;
this.tradingService = tradingService;
}
public void Start()
{
loggingService.Info($"Start Backtesting service... (Replay: {this.Config.Replay})");
signalsService = Application.Resolve <ISignalsService>();
tradingService = Application.Resolve <ITradingService>();
if (this.Config.Replay)
{
backtestingLoadSnapshotsTimedTask = tasksService.AddTask(
name: nameof(BacktestingLoadSnapshotsTimedTask),
task: new BacktestingLoadSnapshotsTimedTask(loggingService, healthCheckService, tradingService, this),
interval: this.Config.SnapshotsInterval / this.Config.ReplaySpeed * 1000,
startDelay: Constants.TaskDelays.HighDelay,
startTask: false,
runNow: false,
skipIteration: 0);
}
backtestingSaveSnapshotsTimedTask = tasksService.AddTask(
name: nameof(BacktestingSaveSnapshotsTimedTask),
task: new BacktestingSaveSnapshotsTimedTask(loggingService, healthCheckService, tradingService, signalsService, this),
interval: this.Config.SnapshotsInterval * 1000,
startDelay: Constants.TaskDelays.HighDelay,
startTask: false,
runNow: false,
skipIteration: 0);
if (this.Config.DeleteLogs)
{
loggingService.DeleteAllLogs();
}
string virtualAccountPath = Path.Combine(Directory.GetCurrentDirectory(), tradingService.Config.VirtualAccountFilePath);
if (File.Exists(virtualAccountPath) && (this.Config.DeleteAccountData || !String.IsNullOrWhiteSpace(this.Config.CopyAccountDataPath)))
{
File.Delete(virtualAccountPath);
}
if (!String.IsNullOrWhiteSpace(this.Config.CopyAccountDataPath))
{
File.Copy(Path.Combine(Directory.GetCurrentDirectory(), this.Config.CopyAccountDataPath), virtualAccountPath, true);
}
if (this.Config.Replay)
{
Application.Speed = this.Config.ReplaySpeed;
}
Application.Resolve <ICoreService>().Started += this.OnCoreServiceStarted;
loggingService.Info("Backtesting service started");
}
public MarketSelectorViewModel(ITradingService tradingService)
{
_tradingService = tradingService;
BrowseNodeCommand = new RelayCommand <string>(BrowseNode);
BrowseBackCommand = new RelayCommand(BrowseBack);
CancelCommand = new RelayCommand(Cancel);
ValidateCommand = new RelayCommand <BrowseMarketModel>(Validate);
Title = "Select market";
}
public OptionsSelectorViewModel(ITradingService tradingService)
{
_tradingService = tradingService;
Title = "Select options";
BrowseNodeCommand = new RelayCommand <string>(BrowseNode);
BrowseBackCommand = new RelayCommand(BrowseBack);
AddMarketCommand = new RelayCommand <BrowseMarketModel>(AddMarket);
RemoveMarketCommand = new RelayCommand <BrowseMarketModel>(RemoveMarket);
ValidateCommand = new RelayCommand(Validate, CanValidate);
}
public TradingViewCryptoSignalPollingTimedTask(ILoggingService loggingService, IHealthCheckService healthCheckService,
ITradingService tradingService, TradingViewCryptoSignalReceiver signalReceiver)
{
this.loggingService = loggingService;
this.healthCheckService = healthCheckService;
this.tradingService = tradingService;
this.signalReceiver = signalReceiver;
signalsSerializer = new JsonSerializer();
signalsSerializer.Converters.Add(new TradingViewCryptoSignalConverter());
httpClient = this.CreateHttpClient();
}
public DashboardViewModel(BaseMainViewModel mainViewModel, ITradingService tradingService)
{
_mainViewModel = mainViewModel as MainViewModel;
_tradingService = tradingService;
Title = "Dashboard";
OpenMarketCommand = new RelayCommand(OpenMarket);
OpenSettingsCommand = new RelayCommand(OpenSettings);
OpenGraphCommand = new RelayCommand <PositionModel>(OpenGraph);
}
public IActionResult RefreshAccount()
{
if (!Application.Resolve <ICoreService>().Config.ReadOnlyMode)
{
ITradingService tradingService = Application.Resolve <ITradingService>();
tradingService.Account.Refresh();
return(new OkResult());
}
else
{
return(new BadRequestResult());
}
}
public LoginViewModel(BaseMainViewModel mainViewModel, ITradingService tradingService, ISettingsService settingsService)
{
_mainViewModel = mainViewModel;
_tradingService = tradingService;
_settingsService = settingsService;
Title = "Login";
LoadSettings();
LoginCommand = new RelayCommand <string>(Login, p => !IsLogged || (!string.IsNullOrEmpty(Username) && !string.IsNullOrEmpty(p) && string.IsNullOrEmpty(ApiKey)));
ConnectCommand = new RelayCommand(Connect, () => _tradingService.IsLogged && SelectedAccount != null);
}
public StatsViewModel Stats()
{
ICoreService coreService = Application.Resolve <ICoreService>();
ITradingService tradingService = Application.Resolve <ITradingService>();
decimal accountInitialBalance = tradingService.Config.VirtualTrading
? tradingService.Config.VirtualAccountInitialBalance
: tradingService.Config.AccountInitialBalance;
DateTimeOffset accountInitialBalanceDate = tradingService.Config.VirtualTrading
? DateTimeOffset.Now.AddDays(-30)
: tradingService.Config.AccountInitialBalanceDate;
var model = new StatsViewModel
{
InstanceName = coreService.Config.InstanceName,
Version = coreService.Version,
ReadOnlyMode = coreService.Config.ReadOnlyMode,
TimezoneOffset = coreService.Config.TimezoneOffset,
AccountInitialBalance = accountInitialBalance,
AccountBalance = tradingService.Account.GetTotalBalance(),
Market = tradingService.Config.Market,
Balances = new Dictionary <DateTimeOffset, decimal>(),
Trades = GetTrades()
};
foreach (KeyValuePair <DateTimeOffset, List <TradeResult> > kvp in model.Trades.OrderBy(k => k.Key))
{
DateTimeOffset date = kvp.Key;
List <TradeResult> trades = kvp.Value;
model.Balances[date] = accountInitialBalance;
if (date > accountInitialBalanceDate.Date)
{
for (int d = 1; d < (int)(date - accountInitialBalanceDate.Date).TotalDays; d++)
{
DateTimeOffset prevDate = date.AddDays(-d);
if (model.Trades.ContainsKey(prevDate))
{
model.Balances[date] += model.Trades[prevDate].Where(t => !t.IsSwap).Sum(t => t.Profit);
}
}
}
}
return(model);
}
public TradingInstrumentsController(
IAssetsRepository assetsRepository,
IAssetPairsRepository assetPairsRepository,
ITradingConditionsRepository tradingConditionsRepository,
ITradingInstrumentsRepository tradingInstrumentsRepository,
ITradingService tradingService,
IConvertService convertService,
IEventSender eventSender,
DefaultTradingInstrumentSettings defaultTradingInstrumentSettings)
{
_assetsRepository = assetsRepository;
_assetPairsRepository = assetPairsRepository;
_tradingConditionsRepository = tradingConditionsRepository;
_tradingInstrumentsRepository = tradingInstrumentsRepository;
_tradingService = tradingService;
_convertService = convertService;
_eventSender = eventSender;
_defaultTradingInstrumentSettings = defaultTradingInstrumentSettings;
}
public StockAppHandler(IExecutionVenueService executionVenueService, ICreditCheckService creditCheckService, ITradingService tradingService)
{
this.executionVenueService = executionVenueService;
this.creditCheckService = creditCheckService;
this.tradingService = tradingService;
}
