567 lines
19 KiB
C#
567 lines
19 KiB
C#
using System;
|
|
using System.IO;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.Linq;
|
|
using System.Net;
|
|
using System.Threading.Tasks;
|
|
using System.Diagnostics;
|
|
using Newtonsoft.Json.Linq;
|
|
using Core.Main.DataObjects.PTMagicData;
|
|
|
|
namespace Core.Main.DataObjects
|
|
{
|
|
|
|
public class ProfitTrailerData
|
|
{
|
|
private SummaryData _summary = null;
|
|
private Properties _properties = null;
|
|
private List<SellLogData> _sellLog = new List<SellLogData>();
|
|
private List<DCALogData> _dcaLog = new List<DCALogData>();
|
|
private List<BuyLogData> _buyLog = new List<BuyLogData>();
|
|
private string _ptmBasePath = "";
|
|
private PTMagicConfiguration _systemConfiguration = null;
|
|
private TransactionData _transactionData = null;
|
|
private DateTime _buyLogRefresh = DateTime.UtcNow, _sellLogRefresh = DateTime.UtcNow, _dcaLogRefresh = DateTime.UtcNow, _summaryRefresh = DateTime.UtcNow, _propertiesRefresh = DateTime.UtcNow;
|
|
private volatile object _buyLock = new object(), _sellLock = new object(), _dcaLock = new object(), _summaryLock = new object(), _propertiesLock = new object();
|
|
private TimeSpan? _offsetTimeSpan = null;
|
|
|
|
// Constructor
|
|
public ProfitTrailerData(PTMagicConfiguration systemConfiguration)
|
|
{
|
|
_systemConfiguration = systemConfiguration;
|
|
}
|
|
|
|
// Get a time span for the UTC offset from the settings
|
|
private TimeSpan OffsetTimeSpan
|
|
{
|
|
get
|
|
{
|
|
if (!_offsetTimeSpan.HasValue)
|
|
{
|
|
// Get offset for settings.
|
|
_offsetTimeSpan = TimeSpan.Parse(_systemConfiguration.GeneralSettings.Application.TimezoneOffset.Replace("+", ""));
|
|
}
|
|
|
|
return _offsetTimeSpan.Value;
|
|
}
|
|
}
|
|
|
|
// Get the time with the settings UTC offset applied
|
|
private DateTimeOffset LocalizedTime
|
|
{
|
|
get
|
|
{
|
|
return DateTimeOffset.UtcNow.ToOffset(OffsetTimeSpan);
|
|
}
|
|
}
|
|
|
|
public SummaryData Summary
|
|
{
|
|
get
|
|
{
|
|
if (_summary == null || (DateTime.UtcNow > _summaryRefresh))
|
|
{
|
|
lock (_summaryLock)
|
|
{
|
|
// Thread double locking
|
|
if (_summary == null || (DateTime.UtcNow > _summaryRefresh))
|
|
{
|
|
_summary = BuildSummaryData(GetDataFromProfitTrailer("api/v2/data/misc"));
|
|
_summaryRefresh = DateTime.UtcNow.AddSeconds(_systemConfiguration.GeneralSettings.Monitor.RefreshSeconds - 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
return _summary;
|
|
}
|
|
}
|
|
public Properties Properties
|
|
{
|
|
get
|
|
{
|
|
if (_properties == null || (DateTime.UtcNow > _propertiesRefresh))
|
|
{
|
|
lock (_propertiesLock)
|
|
{
|
|
// Thread double locking
|
|
if (_properties == null || (DateTime.UtcNow > _propertiesRefresh))
|
|
{
|
|
_properties = BuildProptertiesData(GetDataFromProfitTrailer("api/v2/data/properties"));
|
|
_propertiesRefresh = DateTime.UtcNow.AddSeconds(_systemConfiguration.GeneralSettings.Monitor.RefreshSeconds - 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
return _properties;
|
|
}
|
|
}
|
|
public List<SellLogData> SellLog
|
|
{
|
|
get
|
|
{
|
|
if (_sellLog == null || (DateTime.UtcNow > _sellLogRefresh))
|
|
{
|
|
lock (_sellLock)
|
|
{
|
|
// Thread double locking
|
|
if (_sellLog == null || (DateTime.UtcNow > _sellLogRefresh))
|
|
{
|
|
_sellLog.Clear();
|
|
|
|
// Page through the sales data summarizing it.
|
|
bool exitLoop = false;
|
|
int pageIndex = 1;
|
|
|
|
int maxPages = _systemConfiguration.GeneralSettings.Monitor.MaxSalesRecords;
|
|
int requestedPages = 0;
|
|
|
|
while (!exitLoop && requestedPages < maxPages)
|
|
{
|
|
var sellDataPage = GetDataFromProfitTrailer("/api/v2/data/sales?Page=1&perPage=1&sort=SOLDDATE&sortDirection=DESCENDING&page=" + pageIndex);
|
|
if (sellDataPage != null && sellDataPage.data.Count > 0)
|
|
{
|
|
// Add sales data page to collection
|
|
this.BuildSellLogData(sellDataPage);
|
|
pageIndex++;
|
|
requestedPages++;
|
|
|
|
}
|
|
else
|
|
{
|
|
// All data retrieved
|
|
exitLoop = true;
|
|
}
|
|
}
|
|
|
|
// Update sell log refresh time
|
|
_sellLogRefresh = DateTime.UtcNow.AddSeconds(_systemConfiguration.GeneralSettings.Monitor.RefreshSeconds -1);
|
|
}
|
|
}
|
|
}
|
|
|
|
return _sellLog;
|
|
}
|
|
}
|
|
|
|
public List<SellLogData> SellLogToday
|
|
{
|
|
get
|
|
{
|
|
return SellLog.FindAll(sl => sl.SoldDate.Date == LocalizedTime.DateTime.Date);
|
|
}
|
|
}
|
|
|
|
public List<SellLogData> SellLogYesterday
|
|
{
|
|
get
|
|
{
|
|
return SellLog.FindAll(sl => sl.SoldDate.Date == LocalizedTime.DateTime.AddDays(-1).Date);
|
|
}
|
|
}
|
|
|
|
public List<SellLogData> SellLogLast7Days
|
|
{
|
|
get
|
|
{
|
|
return SellLog.FindAll(sl => sl.SoldDate.Date >= LocalizedTime.DateTime.AddDays(-7).Date);
|
|
}
|
|
}
|
|
|
|
public List<SellLogData> SellLogLast30Days
|
|
{
|
|
get
|
|
{
|
|
return SellLog.FindAll(sl => sl.SoldDate.Date >= LocalizedTime.DateTime.AddDays(-30).Date);
|
|
}
|
|
}
|
|
|
|
public List<DCALogData> DCALog
|
|
{
|
|
get
|
|
{
|
|
if (_dcaLog == null || (DateTime.UtcNow > _dcaLogRefresh))
|
|
{
|
|
lock (_dcaLock)
|
|
{
|
|
// Thread double locking
|
|
if (_dcaLog == null || (DateTime.UtcNow > _dcaLogRefresh))
|
|
{
|
|
dynamic dcaData = null, pairsData = null, pendingData = null, watchData = null;
|
|
_dcaLog.Clear();
|
|
|
|
Parallel.Invoke(() =>
|
|
{
|
|
dcaData = GetDataFromProfitTrailer("/api/v2/data/dca", true);
|
|
},
|
|
() =>
|
|
{
|
|
pairsData = GetDataFromProfitTrailer("/api/v2/data/pairs", true);
|
|
},
|
|
() =>
|
|
{
|
|
pendingData = GetDataFromProfitTrailer("/api/v2/data/pending", true);
|
|
|
|
},
|
|
() =>
|
|
{
|
|
watchData = GetDataFromProfitTrailer("/api/v2/data/watchmode", true);
|
|
});
|
|
|
|
this.BuildDCALogData(dcaData, pairsData, pendingData, watchData);
|
|
_dcaLogRefresh = DateTime.UtcNow.AddSeconds(_systemConfiguration.GeneralSettings.Monitor.BagAnalyzerRefreshSeconds - 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
return _dcaLog;
|
|
}
|
|
}
|
|
|
|
public List<BuyLogData> BuyLog
|
|
{
|
|
get
|
|
{
|
|
if (_buyLog == null || (DateTime.UtcNow > _buyLogRefresh))
|
|
{
|
|
lock (_buyLock)
|
|
{
|
|
// Thread double locking
|
|
if (_buyLog == null || (DateTime.UtcNow > _buyLogRefresh))
|
|
{
|
|
_buyLog.Clear();
|
|
this.BuildBuyLogData(GetDataFromProfitTrailer("/api/v2/data/pbl", true));
|
|
_buyLogRefresh = DateTime.UtcNow.AddSeconds(_systemConfiguration.GeneralSettings.Monitor.BuyAnalyzerRefreshSeconds - 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
return _buyLog;
|
|
}
|
|
}
|
|
|
|
public TransactionData TransactionData
|
|
{
|
|
get
|
|
{
|
|
if (_transactionData == null) _transactionData = new TransactionData(_ptmBasePath);
|
|
return _transactionData;
|
|
}
|
|
}
|
|
|
|
public double GetCurrentBalance()
|
|
{
|
|
return
|
|
(this.Summary.Balance);
|
|
}
|
|
public double GetPairsBalance()
|
|
{
|
|
return
|
|
(this.Summary.PairsValue);
|
|
}
|
|
public double GetDCABalance()
|
|
{
|
|
return
|
|
(this.Summary.DCAValue);
|
|
}
|
|
public double GetPendingBalance()
|
|
{
|
|
return
|
|
(this.Summary.PendingValue);
|
|
}
|
|
public double GetDustBalance()
|
|
{
|
|
return
|
|
(this.Summary.DustValue);
|
|
}
|
|
|
|
public double GetSnapshotBalance(DateTime snapshotDateTime)
|
|
{
|
|
double result = _systemConfiguration.GeneralSettings.Application.StartBalance;
|
|
|
|
result += this.SellLog.FindAll(sl => sl.SoldDate.Date < snapshotDateTime.Date).Sum(sl => sl.Profit);
|
|
result += this.TransactionData.Transactions.FindAll(t => t.UTCDateTime < snapshotDateTime).Sum(t => t.Amount);
|
|
|
|
// Calculate holdings for snapshot date
|
|
result += this.DCALog.FindAll(pairs => pairs.FirstBoughtDate <= snapshotDateTime).Sum(pairs => pairs.CurrentValue);
|
|
|
|
return result;
|
|
}
|
|
|
|
private dynamic GetDataFromProfitTrailer(string callPath, bool arrayReturned = false)
|
|
{
|
|
string rawBody = "";
|
|
string url = string.Format("{0}{1}{2}token={3}", _systemConfiguration.GeneralSettings.Application.ProfitTrailerMonitorURL,
|
|
callPath,
|
|
callPath.Contains("?") ? "&" : "?",
|
|
_systemConfiguration.GeneralSettings.Application.ProfitTrailerServerAPIToken);
|
|
|
|
// Get the data from PT
|
|
Debug.WriteLine(String.Format("{0} - Calling '{1}'", DateTime.UtcNow, url));
|
|
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
|
|
request.AutomaticDecompression = DecompressionMethods.GZip;
|
|
request.KeepAlive = true;
|
|
|
|
WebResponse response = request.GetResponse();
|
|
|
|
using (Stream dataStream = response.GetResponseStream())
|
|
{
|
|
StreamReader reader = new StreamReader(dataStream);
|
|
rawBody = reader.ReadToEnd();
|
|
reader.Close();
|
|
}
|
|
|
|
response.Close();
|
|
|
|
// Parse the JSON and build the data sets
|
|
if (!arrayReturned)
|
|
{
|
|
return JObject.Parse(rawBody);
|
|
}
|
|
else
|
|
{
|
|
return JArray.Parse(rawBody);
|
|
}
|
|
}
|
|
|
|
private SummaryData BuildSummaryData(dynamic PTData)
|
|
{
|
|
return new SummaryData()
|
|
{
|
|
Market = PTData.market,
|
|
Balance = PTData.realBalance,
|
|
PairsValue = PTData.totalPairsCurrentValue,
|
|
DCAValue = PTData.totalDCACurrentValue,
|
|
PendingValue = PTData.totalPendingCurrentValue,
|
|
DustValue = PTData.totalDustCurrentValue
|
|
};
|
|
}
|
|
private Properties BuildProptertiesData(dynamic PTProperties)
|
|
{
|
|
return new Properties()
|
|
{
|
|
Currency = PTProperties.currency,
|
|
Shorting = PTProperties.shorting,
|
|
Margin = PTProperties.margin,
|
|
UpTime = PTProperties.upTime,
|
|
Port = PTProperties.port,
|
|
IsLeverageExchange = PTProperties.isLeverageExchange,
|
|
BaseUrl = PTProperties.baseUrl
|
|
};
|
|
}
|
|
private void BuildSellLogData(dynamic rawSellLogData)
|
|
{
|
|
foreach (var rsld in rawSellLogData.data)
|
|
{
|
|
SellLogData sellLogData = new SellLogData();
|
|
sellLogData.SoldAmount = rsld.soldAmount;
|
|
sellLogData.BoughtTimes = rsld.boughtTimes;
|
|
sellLogData.Market = rsld.market;
|
|
sellLogData.ProfitPercent = rsld.profit;
|
|
sellLogData.SoldPrice = rsld.currentPrice;
|
|
sellLogData.AverageBuyPrice = rsld.avgPrice;
|
|
sellLogData.TotalCost = rsld.totalCost;
|
|
sellLogData.Profit = rsld.profitCurrency;
|
|
|
|
|
|
//Convert Unix Timestamp to Datetime
|
|
System.DateTime dtDateTime = new DateTime(1970, 1, 1, 0, 0, 0, System.DateTimeKind.Utc);
|
|
dtDateTime = dtDateTime.AddSeconds((double)rsld.soldDate).ToUniversalTime();
|
|
|
|
// Profit Trailer sales are saved in UTC
|
|
DateTimeOffset ptSoldDate = DateTimeOffset.Parse(dtDateTime.Year.ToString() + "-" + dtDateTime.Month.ToString("00") + "-" + dtDateTime.Day.ToString("00") + "T" + dtDateTime.Hour.ToString("00") + ":" + dtDateTime.Minute.ToString("00") + ":" + dtDateTime.Second.ToString("00"), CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal);
|
|
|
|
// Convert UTC sales time to local offset time
|
|
ptSoldDate = ptSoldDate.ToOffset(OffsetTimeSpan);
|
|
|
|
sellLogData.SoldDate = ptSoldDate.DateTime;
|
|
|
|
_sellLog.Add(sellLogData);
|
|
}
|
|
}
|
|
|
|
private void BuildDCALogData(dynamic rawDCALogData, dynamic rawPairsLogData, dynamic rawPendingLogData, dynamic rawWatchModeLogData)
|
|
{
|
|
// Parse DCA data
|
|
_dcaLog.AddRange(ParsePairsData(rawDCALogData, true));
|
|
|
|
// Parse Pairs data
|
|
_dcaLog.AddRange(ParsePairsData(rawPairsLogData, false));
|
|
|
|
// Parse pending pairs data
|
|
_dcaLog.AddRange(ParsePairsData(rawPendingLogData, false));
|
|
|
|
// Parse watch only pairs data
|
|
_dcaLog.AddRange(ParsePairsData(rawWatchModeLogData, false));
|
|
|
|
}
|
|
|
|
// Parse the pairs data from PT to our own common data structure.
|
|
private List<DCALogData> ParsePairsData(dynamic pairsData, bool processBuyStrategies)
|
|
{
|
|
List<DCALogData> pairs = new List<DCALogData>();
|
|
|
|
foreach (var pair in pairsData)
|
|
{
|
|
DCALogData dcaLogData = new DCALogData();
|
|
dcaLogData.Amount = pair.totalAmount;
|
|
dcaLogData.BoughtTimes = pair.boughtTimes;
|
|
dcaLogData.Market = pair.market;
|
|
dcaLogData.ProfitPercent = pair.profit;
|
|
dcaLogData.AverageBuyPrice = pair.avgPrice;
|
|
dcaLogData.TotalCost = pair.totalCost;
|
|
dcaLogData.BuyTriggerPercent = pair.buyProfit;
|
|
dcaLogData.CurrentLowBBValue = pair.bbLow == null ? 0 : pair.bbLow;
|
|
dcaLogData.CurrentHighBBValue = pair.highBb == null ? 0 : pair.highBb;
|
|
dcaLogData.BBTrigger = pair.bbTrigger == null ? 0 : pair.bbTrigger;
|
|
dcaLogData.CurrentPrice = pair.currentPrice;
|
|
dcaLogData.SellTrigger = pair.triggerValue == null ? 0 : pair.triggerValue;
|
|
dcaLogData.PercChange = pair.percChange;
|
|
dcaLogData.Leverage = pair.leverage == null ? 0 : pair.leverage;
|
|
dcaLogData.BuyStrategy = pair.buyStrategy == null ? "" : pair.buyStrategy;
|
|
dcaLogData.SellStrategy = pair.sellStrategy == null ? "" : pair.sellStrategy;
|
|
dcaLogData.IsTrailing = false;
|
|
|
|
// See if they are using PT 2.5 (buyStrategiesData) or 2.4 (buyStrategies)
|
|
var buyStrats = pair.buyStrategies != null ? pair.buyStrategies : pair.buyStrategiesData.data;
|
|
if (buyStrats != null && processBuyStrategies)
|
|
{
|
|
foreach (var bs in buyStrats)
|
|
{
|
|
Strategy buyStrategy = new Strategy();
|
|
buyStrategy.Type = bs.type;
|
|
buyStrategy.Name = bs.name;
|
|
buyStrategy.EntryValue = bs.entryValue;
|
|
buyStrategy.EntryValueLimit = bs.entryValueLimit;
|
|
buyStrategy.TriggerValue = bs.triggerValue;
|
|
buyStrategy.CurrentValue = bs.currentValue;
|
|
buyStrategy.CurrentValuePercentage = bs.currentValuePercentage;
|
|
buyStrategy.Decimals = bs.decimals;
|
|
buyStrategy.IsTrailing = bs.trailing;
|
|
buyStrategy.IsTrue = bs.strategyResult;
|
|
|
|
dcaLogData.BuyStrategies.Add(buyStrategy);
|
|
}
|
|
}
|
|
|
|
// See if they are using PT 2.5 (sellStrategiesData) or 2.4 (sellStrategies)
|
|
var sellStrats = pair.sellStrategies != null ? pair.sellStrategies : pair.sellStrategiesData.data;
|
|
if (sellStrats != null)
|
|
{
|
|
foreach (var ss in sellStrats)
|
|
{
|
|
Strategy sellStrategy = new Strategy();
|
|
sellStrategy.Type = ss.type;
|
|
sellStrategy.Name = ss.name;
|
|
sellStrategy.EntryValue = ss.entryValue;
|
|
sellStrategy.EntryValueLimit = ss.entryValueLimit;
|
|
sellStrategy.TriggerValue = ss.triggerValue;
|
|
sellStrategy.CurrentValue = ss.currentValue;
|
|
sellStrategy.CurrentValuePercentage = ss.currentValuePercentage;
|
|
sellStrategy.Decimals = ss.decimals;
|
|
sellStrategy.IsTrailing = ss.trailing;
|
|
sellStrategy.IsTrue = ss.strategyResult;
|
|
|
|
dcaLogData.SellStrategies.Add(sellStrategy);
|
|
|
|
// Find the target percentage gain to sell.
|
|
if (sellStrategy.Name.Contains("GAIN", StringComparison.InvariantCultureIgnoreCase))
|
|
{
|
|
if (!dcaLogData.TargetGainValue.HasValue || dcaLogData.TargetGainValue.Value > sellStrategy.EntryValue)
|
|
{
|
|
// Set the target sell percentage
|
|
dcaLogData.TargetGainValue = sellStrategy.EntryValue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Calculate current value
|
|
dcaLogData.CurrentValue = dcaLogData.CurrentPrice * dcaLogData.Amount;
|
|
|
|
// Convert Unix Timestamp to Datetime
|
|
System.DateTime rdldDateTime = new DateTime(1970, 1, 1, 0, 0, 0, System.DateTimeKind.Utc);
|
|
rdldDateTime = rdldDateTime.AddSeconds((double)pair.firstBoughtDate).ToUniversalTime();
|
|
|
|
// Profit Trailer bought times are saved in UTC
|
|
if (pair.firstBoughtDate > 0)
|
|
{
|
|
DateTimeOffset ptFirstBoughtDate = DateTimeOffset.Parse(rdldDateTime.Year.ToString() + "-" + rdldDateTime.Month.ToString("00") + "-" + rdldDateTime.Day.ToString("00") + "T" + rdldDateTime.Hour.ToString("00") + ":" + rdldDateTime.Minute.ToString("00") + ":" + rdldDateTime.Second.ToString("00"), CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal);
|
|
|
|
// Convert UTC bought time to local offset time
|
|
ptFirstBoughtDate = ptFirstBoughtDate.ToOffset(OffsetTimeSpan);
|
|
|
|
dcaLogData.FirstBoughtDate = ptFirstBoughtDate.DateTime;
|
|
}
|
|
else
|
|
{
|
|
dcaLogData.FirstBoughtDate = Constants.confMinDate;
|
|
}
|
|
|
|
_dcaLog.Add(dcaLogData);
|
|
}
|
|
|
|
return pairs;
|
|
}
|
|
|
|
private void BuildBuyLogData(dynamic rawBuyLogData)
|
|
{
|
|
foreach (var rbld in rawBuyLogData)
|
|
{
|
|
BuyLogData buyLogData = new BuyLogData() { IsTrailing = false, IsTrue = false, IsSom = false, TrueStrategyCount = 0 };
|
|
buyLogData.Market = rbld.market;
|
|
buyLogData.ProfitPercent = rbld.profit;
|
|
buyLogData.CurrentPrice = rbld.currentPrice;
|
|
buyLogData.PercChange = rbld.percChange;
|
|
buyLogData.Volume24h = rbld.volume;
|
|
|
|
if (rbld.positive != null)
|
|
{
|
|
buyLogData.IsTrailing = ((string)(rbld.positive)).IndexOf("trailing", StringComparison.InvariantCultureIgnoreCase) > -1;
|
|
buyLogData.IsTrue = ((string)(rbld.positive)).IndexOf("true", StringComparison.InvariantCultureIgnoreCase) > -1;
|
|
}
|
|
else
|
|
{
|
|
// Parse buy strategies
|
|
|
|
// See if they are using PT 2.5 (buyStrategiesData) or 2.4 (buyStrategies)
|
|
var buyStrats = rbld.buyStrategies != null ? rbld.buyStrategies : rbld.buyStrategiesData.data;
|
|
|
|
if (buyStrats != null)
|
|
{
|
|
foreach (var bs in buyStrats)
|
|
{
|
|
Strategy buyStrategy = new Strategy();
|
|
buyStrategy.Type = bs.type;
|
|
buyStrategy.Name = bs.name;
|
|
buyStrategy.EntryValue = bs.entryValue;
|
|
buyStrategy.EntryValueLimit = bs.entryValueLimit;
|
|
buyStrategy.TriggerValue = bs.triggerValue;
|
|
buyStrategy.CurrentValue = bs.currentValue;
|
|
buyStrategy.CurrentValuePercentage = bs.currentValuePercentage;
|
|
buyStrategy.Decimals = bs.decimals;
|
|
buyStrategy.IsTrailing = bs.trailing;
|
|
buyStrategy.IsTrue = bs.strategyResult;
|
|
|
|
// Is SOM?
|
|
buyLogData.IsSom = buyLogData.IsSom || buyStrategy.Name.Contains("som enabled", StringComparison.OrdinalIgnoreCase);
|
|
|
|
// Is the pair trailing?
|
|
buyLogData.IsTrailing = buyLogData.IsTrailing || buyStrategy.IsTrailing;
|
|
buyLogData.IsTrue = buyLogData.IsTrue || buyStrategy.IsTrue;
|
|
|
|
// True status strategy count total
|
|
buyLogData.TrueStrategyCount += buyStrategy.IsTrue ? 1 : 0;
|
|
|
|
// Add
|
|
buyLogData.BuyStrategies.Add(buyStrategy);
|
|
}
|
|
}
|
|
}
|
|
|
|
_buyLog.Add(buyLogData);
|
|
}
|
|
}
|
|
}
|
|
}
|