public static List <string> FilterByBaseCurency(
this List <string> symbols,
ExchangerEnum exchanger = ExchangerEnum.Bittrex,
BaseCurrencyEnum currency = BaseCurrencyEnum.BTC)
{
return(symbols.Where(s => s.ToUpper().StartsWith(currency.ToString())).ToList());
}
public static List <string> FilterByIgnoreCoins(
this List <string> symbols,
IgnoreCoinSettings[] ignoreCoinSettings,
ExchangerEnum exchanger)
{
if (symbols == null || !symbols.Any())
{
return(symbols);
}
var ignoreSymbol = ignoreCoinSettings.FirstOrDefault(ss => ss.Exchanger.Equals(exchanger.ToString()));
if (ignoreSymbol == null)
{
return(symbols);
}
symbols.RemoveAll(s => ignoreSymbol.Symbols.Contains(SymbolHelper.ToGlobalSymbol(s, exchanger)));
return(symbols);
}
public static List<CoinInfo> FillCoinPrices(
this List<CoinInfo> coins,
ExchangerEnum exchanger,
List<KeyValuePair<string, ExchangeTicker>> marketTickers)
{
if (marketTickers == null || !marketTickers.Any())
{
return coins;
}
foreach (var coin in coins)
{
var ticker = marketTickers.FirstOrDefault(
t => t.Key.Equals(coin.ExchangeSymbol.Binance, StringComparison.OrdinalIgnoreCase)
|| t.Key.Equals(coin.ExchangeSymbol.Bittrex, StringComparison.OrdinalIgnoreCase)
|| t.Key.Equals(coin.ExchangeSymbol.HitBtc, StringComparison.OrdinalIgnoreCase)
|| t.Key.Equals(coin.ExchangeSymbol.KuCoin, StringComparison.OrdinalIgnoreCase)
|| t.Key.Equals(coin.ExchangeSymbol.Cryptopia, StringComparison.OrdinalIgnoreCase)
|| t.Key.Equals(coin.ExchangeSymbol.Okex, StringComparison.OrdinalIgnoreCase)
|| t.Key.Equals(coin.ExchangeSymbol.Gate, StringComparison.OrdinalIgnoreCase)
|| t.Key.Equals(coin.ExchangeSymbol.Huobi, StringComparison.OrdinalIgnoreCase)
|| t.Key.Equals(coin.ExchangeSymbol.Upbit, StringComparison.OrdinalIgnoreCase)
|| t.Key.Equals(coin.ExchangeSymbol.Yobit, StringComparison.OrdinalIgnoreCase));
if (ticker.Key == null)
{
continue;
}
switch (exchanger)
{
case ExchangerEnum.Binance:
{
coin.ExchangePrices.Add(
new ExchangePrice
{
Exchanger = ExchangerEnum.Binance,
LastPrice = ticker.Value.Last
});
break;
}
case ExchangerEnum.Bittrex:
{
coin.ExchangePrices.Add(
new ExchangePrice
{
Exchanger = ExchangerEnum.Bittrex,
LastPrice = ticker.Value.Last
});
break;
}
case ExchangerEnum.HitBtc:
{
coin.ExchangePrices.Add(
new ExchangePrice
{
Exchanger = ExchangerEnum.HitBtc,
LastPrice = ticker.Value.Last
});
break;
}
case ExchangerEnum.KuCoin:
{
coin.ExchangePrices.Add(
new ExchangePrice
{
Exchanger = ExchangerEnum.KuCoin,
LastPrice = ticker.Value.Last
});
break;
}
case ExchangerEnum.Cryptopia:
{
coin.ExchangePrices.Add(
new ExchangePrice
{
Exchanger = ExchangerEnum.Cryptopia,
LastPrice = ticker.Value.Last
});
break;
}
case ExchangerEnum.Yobit:
{
coin.ExchangePrices.Add(
new ExchangePrice
{
Exchanger = ExchangerEnum.Yobit,
LastPrice = ticker.Value.Last
});
break;
}
case ExchangerEnum.Okex:
{
coin.ExchangePrices.Add(
new ExchangePrice
{
Exchanger = ExchangerEnum.Okex,
LastPrice = ticker.Value.Last
});
break;
}
case ExchangerEnum.Gate:
{
coin.ExchangePrices.Add(
new ExchangePrice
{
Exchanger = ExchangerEnum.Gate,
LastPrice = ticker.Value.Last
});
break;
}
case ExchangerEnum.Huobi:
{
coin.ExchangePrices.Add(
new ExchangePrice
{
Exchanger = ExchangerEnum.Huobi,
LastPrice = ticker.Value.Last
});
break;
}
case ExchangerEnum.Upbit:
{
coin.ExchangePrices.Add(
new ExchangePrice
{
Exchanger = ExchangerEnum.Upbit,
LastPrice = ticker.Value.Last
});
break;
}
}
}
return coins;
}
public static List <ExchangeSymbol> FillExchangerSymbols(
this List <ExchangeSymbol> globalSymbols,
ExchangerEnum exchanger,
List <string> symbols)
{
if (symbols == null || !symbols.Any())
{
return(globalSymbols);
}
switch (exchanger)
{
default:
{
return(globalSymbols);
}
case ExchangerEnum.Binance:
{
foreach (var globalSymbol in globalSymbols)
{
foreach (var symbol in symbols)
{
if (SymbolHelper.ToGlobalSymbol(symbol, ExchangerEnum.Binance)
.Equals(globalSymbol.GlobalSymbol))
{
globalSymbol.Binance = symbol;
}
}
}
return(globalSymbols);
}
case ExchangerEnum.Bittrex:
{
foreach (var globalSymbol in globalSymbols)
{
foreach (var symbol in symbols)
{
if (SymbolHelper.ToGlobalSymbol(symbol, ExchangerEnum.Bittrex)
.Equals(globalSymbol.GlobalSymbol))
{
globalSymbol.Bittrex = symbol;
}
}
}
return(globalSymbols);
}
case ExchangerEnum.HitBtc:
{
foreach (var globalSymbol in globalSymbols)
{
foreach (var symbol in symbols)
{
if (SymbolHelper.ToGlobalSymbol(symbol, ExchangerEnum.HitBtc)
.Equals(globalSymbol.GlobalSymbol))
{
globalSymbol.HitBtc = symbol;
}
}
}
return(globalSymbols);
}
case ExchangerEnum.KuCoin:
{
foreach (var globalSymbol in globalSymbols)
{
foreach (var symbol in symbols)
{
if (SymbolHelper.ToGlobalSymbol(symbol, ExchangerEnum.KuCoin)
.Equals(globalSymbol.GlobalSymbol))
{
globalSymbol.KuCoin = symbol;
}
}
}
return(globalSymbols);
}
case ExchangerEnum.Cryptopia:
{
foreach (var globalSymbol in globalSymbols)
{
foreach (var symbol in symbols)
{
if (SymbolHelper.ToGlobalSymbol(symbol, ExchangerEnum.Cryptopia)
.Equals(globalSymbol.GlobalSymbol))
{
globalSymbol.Cryptopia = symbol;
}
}
}
return(globalSymbols);
}
case ExchangerEnum.Yobit:
{
foreach (var globalSymbol in globalSymbols)
{
foreach (var symbol in symbols)
{
if (SymbolHelper.ToGlobalSymbol(symbol, ExchangerEnum.Yobit)
.Equals(globalSymbol.GlobalSymbol))
{
globalSymbol.Yobit = symbol;
}
}
}
return(globalSymbols);
}
case ExchangerEnum.Okex:
{
foreach (var globalSymbol in globalSymbols)
{
foreach (var symbol in symbols)
{
if (SymbolHelper.ToGlobalSymbol(symbol, ExchangerEnum.Okex)
.Equals(globalSymbol.GlobalSymbol))
{
globalSymbol.Okex = symbol;
}
}
}
return(globalSymbols);
}
case ExchangerEnum.Huobi:
{
foreach (var globalSymbol in globalSymbols)
{
foreach (var symbol in symbols)
{
if (SymbolHelper.ToGlobalSymbol(symbol, ExchangerEnum.Huobi)
.Equals(globalSymbol.GlobalSymbol))
{
globalSymbol.Huobi = symbol;
}
}
}
return(globalSymbols);
}
case ExchangerEnum.Gate:
{
foreach (var globalSymbol in globalSymbols)
{
foreach (var symbol in symbols)
{
if (SymbolHelper.ToGlobalSymbol(symbol, ExchangerEnum.Gate)
.Equals(globalSymbol.GlobalSymbol))
{
globalSymbol.Gate = symbol;
}
}
}
return(globalSymbols);
}
case ExchangerEnum.Upbit:
{
foreach (var globalSymbol in globalSymbols)
{
foreach (var symbol in symbols)
{
if (SymbolHelper.ToGlobalSymbol(symbol, ExchangerEnum.Upbit)
.Equals(globalSymbol.GlobalSymbol))
{
globalSymbol.Upbit = symbol;
}
}
}
return(globalSymbols);
}
}
}
public static string ToGlobalSymbol(string symbol, ExchangerEnum exchanger)
{
switch (exchanger)
{
default:
{
return(symbol);
}
case ExchangerEnum.Binance:
{
return(symbol.Replace("-", string.Empty));
}
case ExchangerEnum.Bittrex:
{
// BTC-LTC => LTCBTC
var items = symbol.Split(new[] { '-' }, StringSplitOptions.RemoveEmptyEntries);
return($"{items[1]}{items[0]}");
}
case ExchangerEnum.Okex:
{
// btc_ltc => BTCLTC
return(symbol.Replace("_", string.Empty).ToUpper());
}
case ExchangerEnum.HitBtc:
case ExchangerEnum.Bithumb:
{
return(symbol);
}
case ExchangerEnum.KuCoin:
{
return(symbol.Replace("-", string.Empty));
}
case ExchangerEnum.Cryptopia:
{
return(symbol.Replace("/", string.Empty));
}
case ExchangerEnum.Yobit:
{
return(symbol.Replace("_", string.Empty).ToUpper());
}
case ExchangerEnum.Gate:
{
// eth_btc => BTCETH
var items = symbol.Split(new[] { '_' }, StringSplitOptions.RemoveEmptyEntries);
return($"{items[0].ToUpper()}{items[1].ToUpper()}");
}
case ExchangerEnum.Huobi:
{
return($"{symbol.Replace("btc", string.Empty).ToUpper()}BTC");
}
case ExchangerEnum.Upbit:
{
var items = symbol.Split(new[] { '-' }, StringSplitOptions.RemoveEmptyEntries);
return($"{items[1].ToUpper()}{items[0].ToUpper()}");
}
}
}
