private static CoinDisplay ToCoinDisplay(this CryptoCoin item, Types.CoinCurrency currency)
{
// Why manually and not auto-mapper? Tons of data, and most used method. So Mapster can get slow.
// Also, You cannot cast a child object into a parent object. Need to create a new instance of it or use reflection.
return(new CoinDisplay
{
CoinId = item.CoinId,
Symbol = item.Symbol,
Shares = item.Shares,
OrderDate = item.OrderDate,
PricePerUnit = item.PricePerUnit,
CoinCurrency = item.CoinCurrency,
TotalPricePaidUSD = item.TotalPricePaidUSD,
OrderType = item.OrderType,
Notes = item.Notes,
Exchange = item.Exchange,
SoldCoinCurrency = item.SoldCoinCurrency,
SoldPricePerUnit = item.SoldPricePerUnit,
TotalSoldPricePaidUSD = item.TotalSoldPricePaidUSD,
PortfolioId = item.PortfolioId,
MarketCoin = item.MarketCoin,
GeneratedPricePerUnitETH = item.GeneratedPricePerUnitETH,
CurrentUSDPriceOfBTC = item.CurrentUSDPriceOfBTC,
CurrentUSDPriceOfETH = item.CurrentUSDPriceOfETH,
OrderedDateUSDPriceOfBTC = item.OrderedDateUSDPriceOfBTC,
OrderedDateUSDPriceOfETH = item.OrderedDateUSDPriceOfETH,
DisplayCurrency = currency,
IsCurrentlyCombined = item.IsCurrentlyCombined
});
}
public void GetAllCoinsAndTestProfitLoss()
{
Types.CoinCurrency currency = Types.CoinCurrency.USD;
List <CryptoCoin> coins = Deserialize <List <CryptoCoin> >(TestUtilities.File_ReadAllLinesSingle(TestUtilities.GeneratePath(@"TestFiles\Coins\Portfolio_Ref_12-13-17_BitTrexOnly.json")));
List <MarketCoin> apiFetchedCoins = Deserialize <List <MarketCoin> >(TestUtilities.File_ReadAllLinesSingle(TestUtilities.GeneratePath(@"TestFiles\Coins\CoinMarketCap_12-13-17_getall_coins.json")));
// Todo: for non CoinCurrency.USD items.
// Dictionary<int, HistoricCoinPrice> historicPrices = new Dictionary<int, HistoricCoinPrice>();
// if ((currency == Types.CoinCurrency.BTC || currency == Types.CoinCurrency.ETH) && coins.Any(x => x.OrderDate > DateTime.MinValue)) { historicPrices = await GetAllHistoricCoinPrices(); }
List <CryptoCoin> updatedCoins = CryptoLogic.UpdateCoinsCurrentPrice(coins, apiFetchedCoins, new Dictionary <int, HistoricCoinPrice>(), useCombinedDisplay: true);
List <CoinDisplay> displayModeCoins = updatedCoins.ToCoinDisplay(currency);
CoinsVM vm = new CoinsVM(displayModeCoins)
{
DisplayCurrency = currency
};
//vm.CalculateCurrentHoldingProfit();
//vm.CalculateSoldProfit();
//Console.WriteLine(vm.CurrentHoldingMarketValue());
}
public static string ToWholeNumberByCurrency(this decimal dec, Types.CoinCurrency displayType)
{
if (displayType == Types.CoinCurrency.BTC || displayType == Types.CoinCurrency.ETH)
{
return(dec.ToString(new CultureInfo("en-US")));
}
return(dec.ToRoundedWholeNumber().ToString(new CultureInfo("en-US")));
}
public static List <CoinDisplay> ToCoinDisplay(this List <CryptoCoin> items, Types.CoinCurrency currency)
{
if (items.IsNullOrEmpty())
{
return(new List <CoinDisplay>());
}
return(items.Select(x => x.ToCoinDisplay(currency)).ToList());
}
/// <summary>
/// Gets the latest price of Coin Currency. For example, if we want the current price of BTC, we pass in BTC as coin currency.
/// </summary>
public static decimal GetLatestPriceOfCurrency(Types.CoinCurrency coinCurrency, List <MarketCoin> marketCoins)
{
if (coinCurrency == Types.CoinCurrency.BTC)
{
return(marketCoins.FirstOrDefault(x => x.Symbol == "BTC").CurrentSymbolPriceUSD);
}
if (coinCurrency == Types.CoinCurrency.ETH)
{
return(marketCoins.FirstOrDefault(x => x.Symbol == "ETH").CurrentSymbolPriceUSD);
}
return(0);
}
private static string GetCurrencySymbol(Types.CoinCurrency currency)
{
switch (currency)
{
case Types.CoinCurrency.USD: return("$");
case Types.CoinCurrency.BTC: return("฿");
case Types.CoinCurrency.ETH: return("ξ");
case Types.CoinCurrency.EUR: return("£");
default: return("$");
}
}
/// <summary>
/// Gets the price per unit of the coin based on currency. For example, Coin-USD: $500, Coin-BTC: .1
/// </summary>
public static decimal GetPricePerUnitOfCoin(CryptoCoin coin, Types.CoinCurrency currency)
{
if (currency == Types.CoinCurrency.BTC)
{
return(coin.MarketCoin.CurrentSymbolPriceBTC);
}
if (currency == Types.CoinCurrency.USD)
{
return(coin.MarketCoin.CurrentSymbolPriceUSD);
}
if (currency == Types.CoinCurrency.ETH)
{
return(coin.CurrentSymbolPriceETH);
}
return(0);
}
public async Task <decimal> GetCurrentCoinPrice(string symbol)
{
Types.CoinCurrency predictedCurrency = CryptoLogic.GenerateCoinCurrencyFromSymbol(symbol);
if (predictedCurrency == Types.CoinCurrency.Unknown)
{
return(0);
}
CryptoCoin coin = (await UpdateCoinsCurrentPrice(new List <CryptoCoin> {
new CryptoCoin {
Symbol = symbol.ToUpperInvariant()
}
}, false)).First();
return(CryptoLogic.GetPricePerUnitOfCoin(coin, predictedCurrency));
}
public async Task <JsonResult> GetGeneratedWatchOnlyDetails(string symbol)
{
Types.CoinCurrency predictedCurrency = CryptoLogic.GenerateCoinCurrencyFromSymbol(symbol);
if (predictedCurrency == Types.CoinCurrency.Unknown)
{
return(Json(ResultsItem.Error("Unknown currency type. Please use USD-, BTC-, or ETH-")));
}
CryptoCoin coin = (await UpdateCoinsCurrentPrice(new List <CryptoCoin> {
new CryptoCoin {
Symbol = symbol.ToUpperInvariant()
}
}, false)).First();
if (coin.MarketCoin?.CurrentSymbolPriceUSD <= 0)
{
return(Json(ResultsItem.Error("This coin/symbol was not found. Did you use the correct format? E.g. BTC-XRP")));
}
decimal pricePerUnit = CryptoLogic.GetPricePerUnitOfCoin(coin, predictedCurrency);
decimal quantity = decimal.Round(100 / coin.MarketCoin.CurrentSymbolPriceUSD, 5);
return(Json(new { pricePerUnit, quantity }));
}
public static string Symbol(this Types.CoinCurrency currency)
{
return(GetCurrencySymbol(currency));
}
/// <summary>
/// Gets the latest price of Coin Currency. For example, if we want the current price of BTC, we pass in BTC as coin currency.
/// </summary>
public static decimal GetLatestPriceOfSymbol(string symbol, List <MarketCoin> marketCoins, Types.CoinCurrency currency = Types.CoinCurrency.USD)
{
MarketCoin marketCoin = marketCoins.FirstOrDefault(x => x.Symbol == symbol.Split('-')[1].ToUpperInvariant());
if (marketCoin == null)
{
return(0);
}
if (currency == Types.CoinCurrency.USD)
{
return(marketCoin.CurrentSymbolPriceUSD);
}
if (currency == Types.CoinCurrency.BTC)
{
return(marketCoin.CurrentSymbolPriceBTC);
}
if (currency == Types.CoinCurrency.ETH)
{
MarketCoin ethCoin = marketCoins.FirstOrDefault(x => x.Symbol == "ETH");
return(marketCoin.CurrentSymbolPriceUSD / ethCoin.CurrentSymbolPriceUSD);
}
return(0);
}
/// <summary>
/// Get's the price of BTC or ETH at the specified date. For example, how much was BTC on 6/1/2017?
/// Epoch time must be at 12am. Use: DateTime.ToEpochDayAt12am()
/// </summary>
public static decimal GetPriceOfETHorBTCOnSpecificDate(Dictionary <int, HistoricCoinPrice> historicData, int epochTimeInt, Types.CoinCurrency currency)
{
if (historicData.ContainsKey(epochTimeInt))
{
return(currency == Types.CoinCurrency.ETH ? (decimal)historicData[epochTimeInt].USD_ETH_Price : (decimal)historicData[epochTimeInt].USD_BTH_Price);
}
return(0);
}
/// <summary>
/// Calculates the total price paid of a trade. When you place a buy/sell order, you do not know the actual USD price paid/sold.
/// This method will calculate that based on the coin's order date & historic data on BTC/ETH.
/// </summary>
/// <param name="coin">The coin to generate price for</param>
/// <param name="historicData">Historic prices of BTC/ETH</param>
/// <param name="forceUseCurrency">Ignore coin's default currency, and use the forced currency.</param>
/// <returns>Total Price paid USD</returns>
public static decimal GenerateTotalPricePaidUSD(CryptoCoin coin, Dictionary <int, HistoricCoinPrice> historicData, Types.CoinCurrency forceUseCurrency = Types.CoinCurrency.Unknown)
{
// E.g. USDT-BTC -> PricePerUnit (one whole unit): $5000, TotalShares: .5. TotalPricePaidUSD: $2500
if (coin.CoinCurrency == Types.CoinCurrency.USD)
{
return(coin.PricePerUnit * coin.Shares);
}
int epochTimeInt = coin.OrderDate.ToEpochDayAt12am();
if (historicData.ContainsKey(epochTimeInt))
{
// E.g. ETH-GNT -> Currency:ETH. June 1st, 2017, ETH Price: $300. PricePerUnit: .0008, Shares: 5000. CurrentETH: $320, CurrentPPU: .0009
// Total Price Paid: ((.0008*5000)*300)=$1200... CurrentPriceWorth: ((.0009*5000)*320)=$1440. Profit: $240
decimal coinCurrencyPriceUSD = (coin.CoinCurrency == Types.CoinCurrency.ETH || forceUseCurrency == Types.CoinCurrency.ETH)
? (decimal)historicData[epochTimeInt].USD_ETH_Price : (decimal)historicData[epochTimeInt].USD_BTH_Price;
return((coin.PricePerUnit * coin.Shares) * coinCurrencyPriceUSD);
}
return(0);
}
public static List <CryptoCoin> UpdateCoinsCurrentPrice(List <CryptoCoin> coins, List <MarketCoin> apiFetchedCoins, Dictionary <int, HistoricCoinPrice> historicPrices, bool useCombinedDisplay = true, Types.CoinCurrency currency = Types.CoinCurrency.USD)
{
MarketCoin btcCoin = apiFetchedCoins.FirstOrDefault(x => x.Symbol == "BTC");
MarketCoin ethCoin = apiFetchedCoins.FirstOrDefault(x => x.Symbol == "ETH");
if (btcCoin == null || ethCoin == null)
{
return(coins);
}
coins = CorrectCryptoCoinSymbols(coins);
if (useCombinedDisplay)
{
coins = ToCoinsCombinedMode(coins);
}
foreach (CryptoCoin coin in coins)
{
string[] supportedSymbolPrefix = { "BTC-", "ETH-", "USDT-", "USD-" };
if (!supportedSymbolPrefix.Any(x => coin.Symbol.StartsWith(x)))
{
continue;
} // We do not support anything other than BTC, ETH, USD
string[] symbol = coin.Symbol.Contains("-") ? coin.Symbol.Split('-') : new[] { "", coin.Symbol };
coin.CurrentUSDPriceOfBTC = btcCoin.CurrentSymbolPriceUSD;
coin.CurrentUSDPriceOfETH = ethCoin.CurrentSymbolPriceUSD;
if (coin.OrderDate != DateTime.MinValue)
{
coin.OrderedDateUSDPriceOfBTC = GetPriceOfETHorBTCOnSpecificDate(historicPrices, coin.OrderDate.ToEpochDayAt12am(), Types.CoinCurrency.BTC);
if (currency == Types.CoinCurrency.ETH)
{
coin.OrderedDateUSDPriceOfETH = GetPriceOfETHorBTCOnSpecificDate(historicPrices, coin.OrderDate.ToEpochDayAt12am(), Types.CoinCurrency.ETH);
if (coin.OrderedDateUSDPriceOfETH > 0)
{
coin.GeneratedPricePerUnitETH = (coin.TotalPricePaidUSD.GetValueOrDefault() / coin.Shares) / coin.OrderedDateUSDPriceOfETH;
}
}
}
MarketCoin fetchedCoin = apiFetchedCoins.FirstOrDefault(x => x.Symbol.Contains(symbol[1]));
if (fetchedCoin == null)
{
continue;
}
coin.MarketCoin.CurrentSymbolPriceBTC = fetchedCoin.CurrentSymbolPriceBTC;
coin.MarketCoin.CurrentSymbolPriceUSD = fetchedCoin.CurrentSymbolPriceUSD;
coin.MarketCoin.Name = fetchedCoin.Name;
coin.MarketCoin.CoinMarketCapID = fetchedCoin.CoinMarketCapID;
}
return(coins);
}
private async Task <List <CryptoCoin> > UpdateCoinsCurrentPrice(List <CryptoCoin> coins, bool useCombinedDisplay = true, Types.CoinCurrency currency = Types.CoinCurrency.USD)
{
// Get all API coins that has the latest price, and etc. (CoinMarketCap price get)
List <MarketCoin> apiFetchedCoins = await GetAllCoinsMarketDetailsAPI();
Dictionary <int, HistoricCoinPrice> historicPrices = new Dictionary <int, HistoricCoinPrice>();
if ((currency == Types.CoinCurrency.BTC || currency == Types.CoinCurrency.ETH) && coins.Any(x => x.OrderDate > DateTime.MinValue))
{
historicPrices = await GetAllHistoricCoinPrices();
}
return(CryptoLogic.UpdateCoinsCurrentPrice(coins, apiFetchedCoins, historicPrices, useCombinedDisplay, currency));
}
