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 TradingTimedTask(ILoggingService loggingService, INotificationService notificationService, IHealthCheckService healthCheckService, ISignalsService signalsService, TradingService tradingService)
{
this.loggingService = loggingService;
this.notificationService = notificationService;
this.healthCheckService = healthCheckService;
this.signalsService = signalsService;
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 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 void Start()
{
loggingService.Info($"Start Trading service (Virtual: {Config.VirtualTrading})...");
IsTradingSuspended = true;
orderingService = Application.Resolve <IOrderingService>();
rulesService = Application.Resolve <IRulesService>();
OnTradingRulesChanged();
rulesService.RegisterRulesChangeCallback(OnTradingRulesChanged);
Exchange.Start(Config.VirtualTrading);
signalsService = Application.Resolve <ISignalsService>();
if (!Config.VirtualTrading)
{
Account = new ExchangeAccount(loggingService, notificationService, healthCheckService, signalsService, this);
}
else
{
Account = new VirtualAccount(loggingService, notificationService, healthCheckService, signalsService, this);
}
accountRefreshTimedTask = tasksService.AddTask(
name: nameof(AccountRefreshTimedTask),
task: new AccountRefreshTimedTask(loggingService, healthCheckService, this),
interval: Config.AccountRefreshInterval * 1000 / Application.Speed,
startDelay: Constants.TaskDelays.ZeroDelay,
startTask: false,
runNow: true,
skipIteration: 0);
if (signalsService.Config.Enabled)
{
signalsService.Start();
}
tradingTimedTask = tasksService.AddTask(
name: nameof(TradingTimedTask),
task: new TradingTimedTask(loggingService, notificationService, healthCheckService, signalsService, orderingService, this),
interval: Config.TradingCheckInterval * 1000 / Application.Speed,
startDelay: Constants.TaskDelays.NormalDelay,
startTask: false,
runNow: false,
skipIteration: 0);
tradingRulesTimedTask = tasksService.AddTask(
name: nameof(TradingRulesTimedTask),
task: new TradingRulesTimedTask(loggingService, notificationService, healthCheckService, rulesService, signalsService, this),
interval: RulesConfig.CheckInterval * 1000 / Application.Speed,
startDelay: Constants.TaskDelays.MidDelay,
startTask: false,
runNow: false,
skipIteration: 0);
IsTradingSuspended = false;
loggingService.Info("Trading service started");
}
public MarketSignalsResponse MarketSignals()
{
ISignalsService signalsService = Application.Resolve <ISignalsService>();
return(new MarketSignalsResponse
{
Signals = signalsService.GetSignalNames()
});
}
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 void Start()
{
loggingService.Info($"Start Trading service (Virtual: {Config.VirtualTrading})...");
IsTradingSuspended = true;
rulesService = Application.Resolve <IRulesService>();
OnTradingRulesChanged();
rulesService.RegisterRulesChangeCallback(OnTradingRulesChanged);
exchangeService.Start(Config.VirtualTrading);
signalsService = Application.Resolve <ISignalsService>();
if (!Config.VirtualTrading)
{
Account = new ExchangeAccount(loggingService, notificationService, healthCheckService, signalsService, this);
}
else
{
Account = new VirtualAccount(loggingService, notificationService, healthCheckService, signalsService, this);
}
accountTimedTask = new AccountTimedTask(loggingService, healthCheckService, this);
accountTimedTask.Interval = Config.AccountRefreshInterval * 1000 / Application.Speed;
accountTimedTask.Run();
Application.Resolve <ICoreService>().AddTask(nameof(AccountTimedTask), accountTimedTask);
if (signalsService.Config.Enabled)
{
signalsService.Start();
}
tradingTimedTask = new TradingTimedTask(loggingService, notificationService, healthCheckService, signalsService, this);
tradingTimedTask.Interval = Config.TradingCheckInterval * 1000 / Application.Speed;
tradingTimedTask.StartDelay = Constants.TimedTasks.StandardDelay;
tradingTimedTask.LoggingEnabled = !isReplayingSnapshots;
Application.Resolve <ICoreService>().AddTask(nameof(TradingTimedTask), tradingTimedTask);
tradingRulesTimedTask = new TradingRulesTimedTask(loggingService, notificationService, healthCheckService, rulesService, signalsService, this);
tradingRulesTimedTask.Interval = RulesConfig.CheckInterval * 1000 / Application.Speed;
Application.Resolve <ICoreService>().AddTask(nameof(TradingRulesTimedTask), tradingRulesTimedTask);
IsTradingSuspended = false;
loggingService.Info("Trading service started");
}
[HttpGet("status")] // TODO
public StatusApiModel Status()
{
ILoggingService loggingService = Application.Resolve <ILoggingService>();
ITradingService tradingService = Application.Resolve <ITradingService>();
ISignalsService signalsService = Application.Resolve <ISignalsService>();
IHealthCheckService healthCheckService = Application.Resolve <IHealthCheckService>();
var status = new StatusApiModel
{
Balance = tradingService.Account.GetBalance(),
GlobalRating = signalsService.GetGlobalRating()?.ToString("0.000") ?? "N/A",
TrailingBuys = tradingService.GetTrailingBuys(),
TrailingSells = tradingService.GetTrailingSells(),
TrailingSignals = signalsService.GetTrailingSignals(),
TradingSuspended = tradingService.IsTradingSuspended,
HealthChecks = healthCheckService.GetHealthChecks().OrderBy(c => c.Name),
LogEntries = loggingService.GetLogEntries().Reverse().Take(5)
};
return(status);
}
public void Start()
{
loggingService.Info($"Start Backtesting service... (Replay: {Config.Replay})");
signalsService = Application.Resolve <ISignalsService>();
tradingService = Application.Resolve <ITradingService>();
if (Config.Replay)
{
backtestingLoadSnapshotsTimedTask = new BacktestingLoadSnapshotsTimedTask(loggingService, healthCheckService, tradingService, this);
backtestingLoadSnapshotsTimedTask.Interval = Config.SnapshotsInterval / Config.ReplaySpeed * 1000;
backtestingLoadSnapshotsTimedTask.StartDelay = Constants.TimedTasks.StandardDelay;
Application.Resolve <ICoreService>().AddTask(nameof(BacktestingLoadSnapshotsTimedTask), backtestingLoadSnapshotsTimedTask);
}
backtestingSaveSnapshotsTimedTask = new BacktestingSaveSnapshotsTimedTask(loggingService, healthCheckService, tradingService, signalsService, this);
backtestingSaveSnapshotsTimedTask.Interval = Config.SnapshotsInterval * 1000;
backtestingSaveSnapshotsTimedTask.StartDelay = Constants.TimedTasks.StandardDelay;
Application.Resolve <ICoreService>().AddTask(nameof(BacktestingSaveSnapshotsTimedTask), backtestingSaveSnapshotsTimedTask);
if (Config.DeleteLogs)
{
loggingService.DeleteAllLogs();
}
string virtualAccountPath = Path.Combine(Directory.GetCurrentDirectory(), tradingService.Config.VirtualAccountFilePath);
if (File.Exists(virtualAccountPath) && (Config.DeleteAccountData || !String.IsNullOrWhiteSpace(Config.CopyAccountDataPath)))
{
File.Delete(virtualAccountPath);
}
if (!String.IsNullOrWhiteSpace(Config.CopyAccountDataPath))
{
File.Copy(Path.Combine(Directory.GetCurrentDirectory(), Config.CopyAccountDataPath), virtualAccountPath, true);
}
loggingService.Info("Backtesting service started");
}
public ExchangeAccount(ILoggingService loggingService, INotificationService notificationService, IHealthCheckService healthCheckService, ISignalsService signalsService, ITradingService tradingService)
: base(loggingService, notificationService, healthCheckService, signalsService, tradingService)
{
}
public MarketPairsResponse MarketPairs(MarketPairsRequest request)
{
if (request?.SignalsFilter == null)
{
throw new ArgumentNullException(nameof(request));
}
ICoreService coreService = Application.Resolve <ICoreService>();
ITradingService tradingService = Application.Resolve <ITradingService>();
ISignalsService signalsService = Application.Resolve <ISignalsService>();
IEnumerable <ISignal> allSignals = signalsService.GetAllSignals();
if (allSignals != null)
{
if (request.SignalsFilter.Count > 0)
{
allSignals = allSignals.Where(s => request.SignalsFilter.Contains(s.Name));
}
var groupedSignals = allSignals.GroupBy(s => s.Pair).ToDictionary(g => g.Key, g => g.AsEnumerable());
IEnumerable <MarketPairApiModel> marketPairs = from signalGroup in groupedSignals
let pair = signalGroup.Key
let pairConfig = tradingService.GetPairConfig(pair)
select new MarketPairApiModel
{
Name = pair,
TradingViewName = $"{tradingService.Config.Exchange.ToUpperInvariant()}:{pair}",
VolumeList = signalGroup.Value.Select(s => new NameValue <long?>(s.Name, s.Volume)),
VolumeChangeList = signalGroup.Value.Select(s => new NameValue <double?>(s.Name, s.VolumeChange)),
Price = tradingService.GetPrice(pair).ToString("0.00000000"),
PriceChangeList = signalGroup.Value.Select(s => new NameValue <decimal?>(s.Name, s.PriceChange)),
RatingList = signalGroup.Value.Select(s => new NameValue <double?>(s.Name, s.Rating)),
RatingChangeList = signalGroup.Value.Select(s => new NameValue <double?>(s.Name, s.RatingChange)),
VolatilityList = signalGroup.Value.Select(s => new NameValue <double?>(s.Name, s.Volatility)),
Spread = tradingService.Exchange.GetPriceSpread(pair).ToString("0.00"),
ArbitrageList = from market in Enum.GetNames(typeof(ArbitrageMarket)).Where(m => m != tradingService.Config.Market)
let arbitrage = tradingService.Exchange.GetArbitrage(pair, tradingService.Config.Market, new List <ArbitrageMarket> {
Enum.Parse <ArbitrageMarket>(market)
})
select new ArbitrageInfo
{
Name = $"{arbitrage.Market}-{arbitrage.Type.ToString()[0]}",
Arbitrage = arbitrage.IsAssigned ? arbitrage.Percentage.ToString("0.00") : "N/A"
},
SignalRules = signalsService.GetTrailingInfo(pair)?.Select(ti => ti.Rule.Name) ?? Array.Empty <string>(),
HasTradingPair = tradingService.Account.HasTradingPair(pair),
Config = pairConfig
};
return(new MarketPairsResponse
{
MarketPairs = marketPairs.ToList()
});
}
else
{
return(null);
}
}
