public IRuleResult RuleExecuted(Solbot solbot)
{
var result = new SequencedRuleResult();
if (solbot.Actions.StopLossReached &&
solbot.Actions.BoughtPrice == 0 &&
solbot.Actions.StopLossCurrentCycle < solbot.Strategy.AvailableStrategy.StopLossPauseCycles)
{
solbot.Actions.StopLossCurrentCycle++;
result.Success = false;
result.Message = LogGenerator.SequenceError(SequenceName, $"{solbot.Actions.StopLossCurrentCycle}/{solbot.Strategy.AvailableStrategy.StopLossPauseCycles}");
}
else if (!solbot.Actions.StopLossReached &&
solbot.Actions.BoughtPrice > 0)
{
result.Success = true;
result.Message = LogGenerator.SequenceSuccess(SequenceName, $"{solbot.Actions.StopLossCurrentCycle}");
}
else
{
solbot.Actions.StopLossCurrentCycle = 0;
solbot.Actions.BoughtPrice = 0;
solbot.Actions.StopLossReached = false;
result.Success = true;
result.Message = LogGenerator.SequenceSuccess(SequenceName, $"{solbot.Actions.StopLossCurrentCycle}");
}
return(result);
}
public IRuleResult RuleExecuted(Solbot solbot)
{
var result = new SequencedRuleResult();
try
{
var count = _storageService.GetValues().Count;
var storedPriceAverage = AverageContext.Average(
solbot.Strategy.AvailableStrategy.AverageType,
_storageService.GetValues(),
solbot.Communication.Symbol.QuoteAssetPrecision,
solbot.Strategy.AvailableStrategy.Average);
solbot.Communication.Average = new PriceMessage
{
Current = storedPriceAverage,
Count = count < solbot.Strategy.AvailableStrategy.Average
? count
: solbot.Strategy.AvailableStrategy.Average
};
result.Success = true;
result.Message = LogGenerator.SequenceSuccess(SequenceName, $"{storedPriceAverage}");
}
catch (Exception e)
{
result.Success = false;
result.Message = LogGenerator.SequenceException(SequenceName, e);
}
return(result);
}
public IRuleResult RuleExecuted(Solbot solbot)
{
var result = new SequencedRuleResult();
try
{
var currentPrice = _tickerPriceService.GetPriceValue(solbot.Strategy.AvailableStrategy);
if (currentPrice.Success)
{
solbot.Communication.Price = new PriceMessage
{
Current = currentPrice.Result
};
result.Success = true;
result.Message = LogGenerator.SequenceSuccess(SequenceName, $"{currentPrice.Result}");
}
else
{
result.Success = false;
result.Message = LogGenerator.SequenceError(SequenceName, currentPrice.Message);
}
}
catch (Exception e)
{
result.Success = false;
result.Message = LogGenerator.SequenceException(SequenceName, e);
}
return(result);
}
public IRuleResult RuleExecuted(Solbot solbot)
{
var result = new SequencedRuleResult();
try
{
var exchangeInfo = _binanceClient.Spot.System.GetExchangeInfo();
if (exchangeInfo.Success)
{
var symbol = exchangeInfo
.Data
.Symbols
.FirstOrDefault(e => e.Name == solbot.Strategy.AvailableStrategy.Symbol);
if (!(symbol is null) && symbol.Status == SymbolStatus.Trading)
{
solbot.Communication = new Communication
{
Symbol = new SymbolMessage
{
BaseAsset = symbol.BaseAsset,
QuoteAsset = symbol.QuoteAsset,
QuoteAssetPrecision = symbol.QuoteAssetPrecision,
MinNotional = symbol.MinNotionalFilter.MinNotional,
StepSize = symbol.LotSizeFilter.StepSize,
MaxQuantity = symbol.LotSizeFilter.MaxQuantity,
MinQuantity = symbol.LotSizeFilter.MinQuantity,
TickSize = symbol.PriceFilter.TickSize,
MaxPrice = symbol.PriceFilter.MaxPrice,
MinPrice = symbol.PriceFilter.MinPrice
}
};
result.Success = true;
result.Message = LogGenerator.SequenceSuccess(SequenceName, solbot.Strategy.AvailableStrategy.Symbol);
}
else
{
result.Success = false;
result.Message = LogGenerator.SequenceError(SequenceName, solbot.Strategy.AvailableStrategy.Symbol);
}
}
else
{
result.Success = false;
result.Message = LogGenerator.SequenceError(SequenceName, exchangeInfo.Error.Message);
}
}
public IRuleResult RuleExecuted(Solbot solbot)
{
var result = new SequencedRuleResult();
if (_exchange.Type.HasValue)
{
switch (_exchange.Type.Value)
{
case Domain.Enums.ExchangeType.Binance:
{
_rules.Add(new BinanceSymbolSequenceRule(_binanceClient));
_rules.Add(new BinanceGetPriceSequenceRule(_binanceTickerService));
}
break;
case Domain.Enums.ExchangeType.KuCoin:
{
_rules.Add(new KucoinSymbolSequenceRule(_kucoinClient));
_rules.Add(new KucoinGetPriceSequenceRule(_kucoinTickerService));
}
break;
}
foreach (var item in _rules)
{
var res = item.RuleExecuted(solbot);
if (res.Success)
{
result.Success = true;
result.Message = LogGenerator.SequenceSuccess(SequenceName, _exchange.Type.Value.GetDescription());
}
else
{
result.Success = false;
result.Message = LogGenerator.SequenceError(SequenceName, res.Message);
break;
}
}
}
else
{
result.Success = false;
result.Message = "No exchange type provided";
}
return(result);
}
public IRuleResult RuleExecuted(Solbot solbot)
{
var result = new SequencedRuleResult();
try
{
var exchangeInfo = _kucoinClient.GetSymbols();
if (exchangeInfo.Success)
{
var symbol = exchangeInfo
.Data
.FirstOrDefault(e => e.Symbol == solbot.Strategy.AvailableStrategy.Symbol);
if (!(symbol is null) && symbol.EnableTrading)
{
solbot.Communication = new Communication
{
Symbol = new SymbolMessage
{
BaseAsset = symbol.BaseCurrency,
QuoteAsset = symbol.QuoteCurrency,
BasePrecision = symbol.BaseIncrement,
QuotePrecision = symbol.QuoteIncrement,
BaseAssetPrecision = BitConverter.GetBytes(decimal.GetBits(symbol.BaseIncrement)[3])[2],
QuoteAssetPrecision = BitConverter.GetBytes(decimal.GetBits(symbol.QuoteIncrement)[3])[2],
StepSize = symbol.PriceIncrement,
MaxQuantity = symbol.QuoteMaxSize,
MinQuantity = symbol.QuoteMinSize
}
};
result.Success = true;
result.Message = LogGenerator.SequenceSuccess(SequenceName, solbot.Strategy.AvailableStrategy.Symbol);
}
else
{
result.Success = false;
result.Message = LogGenerator.SequenceError(SequenceName, solbot.Strategy.AvailableStrategy.Symbol);
}
}
else
{
result.Success = false;
result.Message = LogGenerator.SequenceError(SequenceName, exchangeInfo.Error.Message);
}
}
public IRuleResult RuleExecuted(Solbot solbot)
{
var result = new SequencedRuleResult();
try
{
_storageService.SaveValue(solbot.Communication.Price.Current);
result.Success = true;
result.Message = LogGenerator.SequenceSuccess(SequenceName, $"{solbot.Communication.Price.Current}");
}
catch (Exception e)
{
result.Success = false;
result.Message = LogGenerator.SequenceException(SequenceName, e);
}
return(result);
}
public IRuleResult RuleExecuted(Solbot solbot)
{
var result = new SequencedRuleResult();
switch (_exchange.Type.Value)
{
case Domain.Enums.ExchangeType.Binance:
{
_rules.Add(new BinanceModeProductionRule(
_marketService,
_pushOverNotificationService,
_binanceClient));
}
break;
case Domain.Enums.ExchangeType.KuCoin:
{
_rules.Add(new KucoinModeProductionRule(
_marketService,
_pushOverNotificationService,
_kucoinClient));
}
break;
}
foreach (var item in _rules)
{
var res = item.RuleExecuted(solbot);
if (res.Success)
{
result.Success = true;
result.Message = LogGenerator.SequenceSuccess(SequenceName, _exchange.Type.Value.GetDescription());
}
else
{
result.Success = false;
result.Message = LogGenerator.SequenceError(SequenceName, res.Message);
break;
}
}
return(result);
}
public IRuleResult RuleExecuted(Solbot solbot)
{
var storagePath = GlobalConfig.PriceFile(solbot.Strategy.AvailableStrategy.Symbol);
var result = new SequencedRuleResult();
try
{
_storageService.SetPath(storagePath);
result.Success = true;
result.Message = LogGenerator.SequenceSuccess(SequenceName, storagePath);
}
catch (Exception e)
{
result.Success = false;
result.Message = LogGenerator.SequenceException(SequenceName, e);
}
return(result);
}
public IRuleResult RuleExecuted(Solbot solbot)
{
var result = new SequencedRuleResult();
var symbol = solbot.Strategy.AvailableStrategy.Symbol;
if (solbot.Strategy.AvailableStrategy.ClearOnStartup && _runForTheFirstTime)
{
try
{
if (_storageService.Exist(symbol))
{
var backup = _storageService.CreateBackup(symbol);
_storageService.ClearFile(symbol);
result.Success = true;
result.Message = LogGenerator.SequenceSuccess(SequenceName, $"{backup}");
}
else
{
result.Success = true;
result.Message = LogGenerator.SequenceSuccess(SequenceName, $"{solbot.Strategy.AvailableStrategy.ClearOnStartup}");
}
}
catch (Exception e)
{
result.Success = false;
result.Message = LogGenerator.SequenceException(SequenceName, e);
}
}
else
{
result.Success = true;
result.Message = LogGenerator.SequenceSuccess(SequenceName, $"{solbot.Strategy.AvailableStrategy.ClearOnStartup}");
}
return(result);
}
public IRuleResult RuleExecuted(Solbot solbot)
{
var result = new SequencedRuleResult
{
Success = true,
Message = LogGenerator.SequenceSuccess(SequenceName, $"Notification ({_pushOverNotificationService.IsActive()})")
};
try
{
if (_runForTheFirstTime)
{
_pushOverNotificationService.Send(
LogGenerator.NotificationTitleStart,
LogGenerator.NotificationMessageStart);
}
}
catch (Exception e)
{
result.Message = LogGenerator.SequenceException(SequenceName, e);
}
return(result);
}
