private void SendEmail(SMSMessage sms, ExchangeData callerDetails)
{
if (sms==null) sms = new SMSMessage();
if (callerDetails==null) callerDetails = new ExchangeData();
var fromAddress = new MailAddress(Properties.Settings.Default.EmailTo, "Incoming SMS");
var toAddress = new MailAddress(Properties.Settings.Default.EmailTo, "SMS Email Queue");
var ccAddress = new MailAddress(Properties.Settings.Default.EmailCC);
var subject = string.Format("Incoming SMS: {0}", sms.From ?? "Unknown");
var getBody = CreateHtmlBody(sms, callerDetails);
var smtp = new SmtpClient();
using (var message = new MailMessage(fromAddress, toAddress)
{
Subject = subject,
Body = getBody,
IsBodyHtml = true
})
{
message.Bcc.Add(ccAddress);
smtp.Send(message);
}
}
public IActionResult Exchange([FromBody] ExchangeData exchangeData)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var result = _operationService.ExchangeCurrency(
exchangeData.date,
exchangeData.currencyFrom,
exchangeData.currencyTo,
exchangeData.currencyValue);
return(Ok(new
{
date = exchangeData.date,
currencyFrom = exchangeData.currencyFrom,
currencyTo = exchangeData.currencyTo,
currencyValue = exchangeData.currencyValue,
currencyValueTo = result
}
));
}
catch (Exception)
{
return(StatusCode(500));
}
}
public UpdateExistingExchange
(ExchangeModel exchange
, ExchangeModelSet exchanges
, ExchangeData data)
{
if (exchange == null)
{
throw new ArgumentNullException(nameof(exchange));
}
if (exchanges == null)
{
throw new ArgumentNullException(nameof(exchanges));
}
if (data == null)
{
throw new ArgumentNullException(nameof(data));
}
if (exchange.Code != data.Code)
{
throw new ArgumentException("Data and model's codes do not match");
}
this.exchange = exchange;
this.exchanges = exchanges;
this.data = data;
}
public SetWindowViewModel()
{
OpenFileCommand = new RelayCommand <object>(OpenFile);
exchangeData = new ExchangeData();
TemplateDataPath = exchangeData.ReadConfigXml("templatePath");
TotalDataPath = exchangeData.ReadConfigXml("totalDataPath");
}
public LoaderService(ExchangeData connectionData)
{
_cache = new List <TradeData>();
_webSocketCahce = new List <TradeData>();
_connectionData = connectionData;
InitServices();
}
async Task <WebCallResult <Ticker> > IBaseRestClient.GetTickerAsync(string symbol, CancellationToken ct)
{
if (string.IsNullOrWhiteSpace(symbol))
{
throw new ArgumentException(nameof(symbol) + " required for Bitfinex " + nameof(ISpotClient.GetTickerAsync), nameof(symbol));
}
var tickersResult = await ExchangeData.GetTickerAsync(symbol, ct : ct).ConfigureAwait(false);
if (!tickersResult)
{
return(tickersResult.As <Ticker>(null));
}
return(tickersResult.As(new Ticker
{
SourceObject = tickersResult.Data,
HighPrice = tickersResult.Data.HighPrice,
LowPrice = tickersResult.Data.LowPrice,
LastPrice = tickersResult.Data.LastPrice,
Price24H = tickersResult.Data.LastPrice - tickersResult.Data.DailyChange,
Symbol = tickersResult.Data.Symbol,
Volume = tickersResult.Data.Volume
}));
}
async Task <WebCallResult <OrderBook> > IBaseRestClient.GetOrderBookAsync(string symbol, CancellationToken ct)
{
if (string.IsNullOrWhiteSpace(symbol))
{
throw new ArgumentException(nameof(symbol) + " required for Bitfinex " + nameof(ISpotClient.GetOrderAsync), nameof(symbol));
}
var orderBookResult = await ExchangeData.GetOrderBookAsync(symbol, Precision.PrecisionLevel0, ct : ct).ConfigureAwait(false);
if (!orderBookResult)
{
return(orderBookResult.As <OrderBook>(null));
}
return(orderBookResult.As(new OrderBook
{
SourceObject = orderBookResult.Data,
Asks = orderBookResult.Data.Asks.Select(a => new OrderBookEntry()
{
Price = a.Price, Quantity = a.Quantity
}),
Bids = orderBookResult.Data.Bids.Select(b => new OrderBookEntry()
{
Price = b.Price, Quantity = b.Quantity
}),
}));
}
async Task <WebCallResult <Ticker> > IBaseRestClient.GetTickerAsync(string symbol, CancellationToken ct)
{
if (string.IsNullOrEmpty(symbol))
{
throw new ArgumentException(nameof(symbol) + " required for CoinEx " + nameof(ISpotClient.GetTickerAsync), nameof(symbol));
}
var tickers = await ExchangeData.GetTickerAsync(symbol, ct : ct).ConfigureAwait(false);
if (!tickers)
{
return(tickers.As <Ticker>(null));
}
return(tickers.As(new Ticker
{
SourceObject = tickers.Data,
Symbol = symbol,
HighPrice = tickers.Data.Ticker.HighPrice,
LowPrice = tickers.Data.Ticker.LowPrice,
LastPrice = tickers.Data.Ticker.LastPrice,
Price24H = tickers.Data.Ticker.OpenPrice,
Volume = tickers.Data.Ticker.Volume
}));
}
async Task <WebCallResult <IEnumerable <Kline> > > IBaseRestClient.GetKlinesAsync(string symbol, TimeSpan timespan, DateTime?startTime, DateTime?endTime, int?limit, CancellationToken ct)
{
if (string.IsNullOrWhiteSpace(symbol))
{
throw new ArgumentException(nameof(symbol) + " required for Bitfinex " + nameof(ISpotClient.GetKlinesAsync), nameof(symbol));
}
var klines = await ExchangeData.GetKlinesAsync(symbol, GetTimeFrameFromTimeSpan(timespan), startTime : startTime, endTime : endTime, limit : limit, ct : ct).ConfigureAwait(false);
if (!klines)
{
return(klines.As <IEnumerable <Kline> >(null));
}
return(klines.As(klines.Data.Select(k =>
new Kline
{
SourceObject = k,
OpenPrice = k.OpenPrice,
OpenTime = k.OpenTime,
ClosePrice = k.ClosePrice,
HighPrice = k.HighPrice,
LowPrice = k.LowPrice,
Volume = k.Volume
})));
}
protected override void Update(dynamic data,
string symbol)
{
symbol = CleanAndExtractSymbol(symbol);
if (ExchangeData.TryGetValue(symbol, out var old))
{
old = old.Clone( );
}
else
{
ExchangeData[symbol] = new CryptoCoin(symbol);
}
DeserializeData(data, symbol);
Markets.AddOrUpdate(ExchangeData[symbol]);
LastUpdate = DateTime.UtcNow;
OnNext(ExchangeData[symbol]);
if (!ExchangeData[symbol].HasSameValues(old))
{
OnChanged(ExchangeData[symbol]);
}
}
public IActionResult OnGetConvert(ExchangeData data)
{
ExchangeData = data;
InitialCurrencyInfo = CurrencyInfoStatic.GetCurrencyInfo(ExchangeData.InitialCurrency);
ReturnCurrencyInfo = CurrencyInfoStatic.GetCurrencyInfo(ExchangeData.ReturnCurrency);
return(Page());
}
private void SendEmail(SMSMessage sms, ExchangeData callerDetails)
{
if (sms == null)
{
sms = new SMSMessage();
}
if (callerDetails == null)
{
callerDetails = new ExchangeData();
}
var fromAddress = new MailAddress(Properties.Settings.Default.EmailTo, "Incoming SMS");
var toAddress = new MailAddress(Properties.Settings.Default.EmailTo, "SMS Email Queue");
var ccAddress = new MailAddress(Properties.Settings.Default.EmailCC);
var subject = string.Format("Incoming SMS: {0}", sms.From ?? "Unknown");
var getBody = CreateHtmlBody(sms, callerDetails);
var smtp = new SmtpClient();
using (var message = new MailMessage(fromAddress, toAddress)
{
Subject = subject,
Body = getBody,
IsBodyHtml = true
})
{
message.Bcc.Add(ccAddress);
smtp.Send(message);
}
}
/// <summary>
/// Convert data from CSV file into Exchange data object
/// </summary>
/// <param name="csvLines"></param>
/// <returns>Return ExchangeData object</returns>
private ExchangeData GetDataFromCsv(string csvLines)
{
var exchangeData = new ExchangeData();
try
{
if (!string.IsNullOrEmpty(csvLines))
{
++_count;
var splitValue = csvLines.Split(',');
exchangeData.TradeDate = ConvertStringToDate(splitValue[0]);
exchangeData.BaseCurrency = CurrencySymbolValidator(splitValue[1]);
exchangeData.CounterCurrency = CurrencySymbolValidator(splitValue[2]);
exchangeData.BaseCurrencyAmount = Convert.ToDouble(splitValue[3]);
exchangeData.ValueDate = ConvertStringToDate(splitValue[4]);
exchangeData.CounterCurrencyAmount = GetAmount(exchangeData);
}
}
catch (Exception ex)
{
ErrorList.Add(string.Format("Error {0} at line number {1}", ex.Message, _count));
}
return(exchangeData);
}
public void AddData(int exchangeID, ExchangeData ed)
{
lock (this._GoodsExchangeDict)
{
this._GoodsExchangeDict[exchangeID] = ed;
}
}
protected override void Update(dynamic data, string symbol, string exchangeName = "")
{
CryptoCoin old = null;
var id = symbol.ToEnum(CryptoCoinId.NULL);
if (ExchangeData.ContainsKey(id))
{
old = ExchangeData[id].Clone( );
}
else
{
ExchangeData[id] = new CryptoCoin(symbol);
}
DeserializeData(data, id);
ApplyFees(id);
LastUpdate = DateTime.UtcNow;
OnNext(ExchangeData[id].Clone( ));
if (ExchangeData[id] != old)
{
OnChanged(ExchangeData[id]);
}
}
public ExchangeData GetAssets(string exhangeName)
{
var client = new RestClient(Static.ExchanesLink);
var request = new RestRequest(Method.GET);
var responseString = client.Execute(request);
var converter = new ExpandoObjectConverter();
var responseObj = JsonConvert.DeserializeObject <ExpandoObject>(responseString.Content, converter);
var exchange = new ExchangeData
{
ExchangeName = exhangeName,
Pairs = new List <ExchangeCurrency>(),
Btc = string.Empty
};
try
{
foreach (var subExchange in responseObj)
{
if (subExchange.Key.Equals(exhangeName))
{
foreach (var pair in (ExpandoObject)subExchange.Value)
{
if (pair.Key.Equals(Static.Btc))
{
var currFrom = pair.Key;
foreach (var currency in (IList)pair.Value)
{
var currTo = (string)currency;
if (currTo.Contains(Static.Usd))
{
exchange.Btc = currFrom + "_" + currTo + "_" + exhangeName;
}
}
}
else
{
foreach (var currency in (IList)pair.Value)
{
if (currency.Equals(Static.Btc))
{
exchange.Pairs.Add(new ExchangeCurrency()
{
CurrencyFrom = pair.Key,
CurrencyTo = currency.ToString()
});
}
}
}
}
}
}
}
catch (Exception e)
{
_logger.LogError($"Error while getting assets for {exhangeName}");
throw new Exception(e.Message);
}
return(exchange);
}
async Task <WebCallResult <OrderBook> > IBaseRestClient.GetOrderBookAsync(string symbol, CancellationToken ct)
{
if (string.IsNullOrEmpty(symbol))
{
throw new ArgumentException(nameof(symbol) + " required for CoinEx " + nameof(ISpotClient.GetOrderBookAsync), nameof(symbol));
}
var book = await ExchangeData.GetOrderBookAsync(symbol, 0, ct : ct).ConfigureAwait(false);
if (!book)
{
return(book.As <OrderBook>(null));
}
return(book.As(new OrderBook
{
SourceObject = book.Data,
Asks = book.Data.Asks.Select(a => new OrderBookEntry {
Price = a.Price, Quantity = a.Quantity
}),
Bids = book.Data.Bids.Select(b => new OrderBookEntry {
Price = b.Price, Quantity = b.Quantity
})
}));
}
async Task <WebCallResult <IEnumerable <Kline> > > IBaseRestClient.GetKlinesAsync(string symbol, TimeSpan timespan, DateTime?startTime, DateTime?endTime, int?limit, CancellationToken ct)
{
if (startTime != null || endTime != null)
{
throw new ArgumentException("CoinEx does not support time based klines requesting", startTime != null ? nameof(startTime) : nameof(endTime));
}
if (string.IsNullOrEmpty(symbol))
{
throw new ArgumentException(nameof(symbol) + " required for CoinEx " + nameof(ISpotClient.GetKlinesAsync), nameof(symbol));
}
var klines = await ExchangeData.GetKlinesAsync(symbol, GetKlineIntervalFromTimespan(timespan), limit, ct : ct).ConfigureAwait(false);
if (!klines)
{
return(klines.As <IEnumerable <Kline> >(null));
}
return(klines.As(klines.Data.Select(t =>
new Kline
{
SourceObject = t,
OpenPrice = t.OpenPrice,
LowPrice = t.LowPrice,
OpenTime = t.OpenTime,
Volume = t.Volume,
ClosePrice = t.ClosePrice,
HighPrice = t.HighPrice
})));
}
public async void TickerThread(ExchangeData Data)
{
InProgress = true;
using (ApiClient = new PoloniexClient(ApiKey, ApiSecret))
{
ApiClient.OnError += (sender, error) =>
{
Data.Status = EnumData.ExchangeStatus.異常;
Data.ErrorMsg = error.Message;
};
ApiClient.OnClose += (sender, e) => { Data.Status = EnumData.ExchangeStatus.停止; };
//USDT_BTC
var SocketResult = ApiClient.SubscribeTicker(Data.ExchangeType, (data) =>
{
Data.Ask = data.Data.Ask;
Data.Bid = data.Data.Bid;
Data.UpdateTime = DateTime.UtcNow;
});
if (!SocketResult.Status)
{
throw new Exception(SocketResult.Message);
}
while (InProgress)
{
Thread.Sleep(500);
}
ApiClient.UnsubscribeFromStream(SocketResult.Data);
}
}
public void TickerThread(ExchangeData Data)
{
InProgress = true;
//BTC-ETH
//USDT-BTC
//BTC-QTUM
using (var BittrexClient = new BittrexClient())
{
while (InProgress)
{
//var markets = BittrexClient.GetMarkets();
//var currencies = BittrexClient.GetCurrencies().Result.Where(x => x.Currency == "BTC" || x.Currency == "USDT").ToList();
//var marketSummary = BittrexClient.GetMarketSummary("BTC-ETH");
//var marketSummaries = BittrexClient.GetMarketSummaries();
//var orderbook = BittrexClient.GetOrderBook("BTC-ETH");
//var marketHistory = BittrexClient.GetMarketHistory("BTC-ETH");
//var list = new List<BittrexCurrency>(currencies);
var Ticker = BittrexClient.GetTicker(Data.ExchangeType);
if (Ticker.Success)
{
Data.Ask = Convert.ToDecimal(Ticker.Result.Ask);
Data.Bid = Convert.ToDecimal(Ticker.Result.Bid);
Data.UpdateTime = DateTime.UtcNow;
}
else
{
Console.WriteLine(Data.Name + "異常");
Console.WriteLine(Ticker.Error);
}
Thread.Sleep(500);
}
//ApiSocketClient.UnsubscribeFromStream(successDepth.Result);
Data.Status = EnumData.ExchangeStatus.停止;
}
//Socket不明原因不能連，疑似官方已關閉
//using (ApiSocketClient = new BittrexSocketClient())
//{
// var successDepth = ApiSocketClient.SubscribeToMarketDeltaStream("USDT-BTC", (data) =>
// {
// Console.WriteLine("USDT-BTC: {0}", data.Last);
// Data.Ask = Convert.ToDouble(data.Ask);
// Data.Bid = Convert.ToDouble(data.Bid);
// Data.UpdateTime = DateTime.UtcNow;
// });
// if (!successDepth.Success)
// {
// Console.WriteLine(Data.Name + "異常");
// Console.WriteLine(successDepth.Error.ErrorMessage);
// //throw new Exception(successDepth.Error.ErrorMessage);
// }
// while (InProgress) Thread.Sleep(500);
// ApiSocketClient.UnsubscribeFromStream(successDepth.Result);
// Data.Status = EnumData.ExchangeStatus.停止;
//}
}
private async void btnPost_Click(object sender, EventArgs e)
{
this.Text = "FriendlyDBName = " + txtFDBN.Text;
string data = "";
string response = "";
txtPubSubLog.Text = "";
XmlDocument datax = new XmlDocument();
if (String.IsNullOrEmpty(txtDataPath.Text))
{
MessageBox.Show(this, "XML path is empty");
return;
}
if (File.Exists(txtDataPath.Text))
{
using (StreamReader reader = File.OpenText(txtDataPath.Text))
{
data = reader.ReadToEnd();
}
datax.LoadXml(data);
}
else
{
MessageBox.Show(this, "XML path is invalid");
return;
}
wbResponse.Navigate(_loadingImage);
try
{
await Task.Factory.StartNew(() =>
{
string sts = "";
if (chkAuthenticate.Checked)
{
var authResponse = Exchange.ClientLib.AuthenticationServiceClient.AuthenticateUser(txtUser.Text, txtPassword.Text, txtFDBN.Text);
if (!authResponse.HasError)
{
sts = authResponse.AuthenticationCookie;
}
}
response = ExchangeData.PostData(txtURL.Text, datax, sts);
});
wbResponse.Navigate(SaveTempResponse(response));
await Task.Factory.StartNew(() => { Subscribe(response); });
}
catch (Exception ex)
{
MessageBox.Show(this, "Check the URL... " + ex.Message, ":-(");
}
}
public void SetData(ExchangeData exchangeData, AnalyticsData analiticsData, List <News> news)
{
Data = exchangeData;
Analitics = analiticsData;
News = news;
NotifyObservers();
}
protected override void OnSetup()
{
ConfigurationManager.AppSettings["MdmCaching"] = false.ToString();
base.OnSetup();
this.exchange = ExchangeData.PostBasicEntity();
}
/// <summary>
/// 交易所買進
/// </summary>
/// <param name="lowestAsk">(買價)最低資訊</param>
/// <param name="MinQuantity">數量</param>
/// <returns></returns>
internal ExchangeApiData PlaceOrderAsk(ExchangeData lowestAsk, decimal MinQuantity)
{
if (string.IsNullOrWhiteSpace(AccountId))
{
ApiClientREST = new HuobiClientREST(ApiKey, ApiSecret);
AccountId = ApiClientREST.AccountId;
}
return(ApiClientREST.ordersPlace("buy-limit", lowestAsk.ExchangeType, MinQuantity, lowestAsk.Ask));
}
/// <summary>
/// 交易所賣出
/// </summary>
/// <param name="highestBid">(賣價)最高資訊</param>
/// <param name="MinQuantity">數量</param>
/// <returns></returns>
internal ExchangeApiData PlaceOrderBid(ExchangeData highestBid, decimal MinQuantity)
{
if (string.IsNullOrWhiteSpace(AccountId))
{
ApiClientREST = new HuobiClientREST(ApiKey, ApiSecret);
AccountId = ApiClientREST.AccountId;
}
return(ApiClientREST.ordersPlace("buy-limit", highestBid.ExchangeType, MinQuantity, highestBid.Bid));
}
/// <summary>
/// 交易所買進
/// </summary>
/// <param name="lowestAsk">(買價)最低資訊</param>
/// <param name="MinQuantity">數量</param>
/// <returns></returns>
internal ExchangeApiData PlaceOrderAsk(ExchangeData lowestAsk, decimal MinQuantity)
{
StockRestApi postRequest1 = new StockRestApi(urlApi, lowestAsk.APIKey, lowestAsk.Secret);
var orderResult = ReturnData(postRequest1.trade(lowestAsk.ExchangeType, "buy", lowestAsk.Ask.ToString(), MinQuantity.ToString()));
return(new ExchangeApiData {
Stace = orderResult.result, Msg = orderResult.Msg
});
}
/// <summary>
/// 交易所賣出
/// </summary>
/// <param name="highestBid">(賣價)最高資訊</param>
/// <param name="MinQuantity">數量</param>
/// <returns></returns>
internal ExchangeApiData PlaceOrderBid(ExchangeData highestBid, decimal MinQuantity)
{
StockRestApi postRequest1 = new StockRestApi(urlApi, highestBid.APIKey, highestBid.Secret);
var orderResult = ReturnData(postRequest1.trade(highestBid.ExchangeType, "sell", highestBid.Bid.ToString(), MinQuantity.ToString()));
return(new ExchangeApiData {
Stace = orderResult.result, Msg = orderResult.Msg
});
}
/// <summary>
/// 交易所賣出
/// </summary>
/// <param name="highestBid">(賣價)最高資訊</param>
/// <param name="MinQuantity">數量</param>
/// <returns></returns>
internal ExchangeApiData PlaceOrderBid(ExchangeData highestBid, decimal MinQuantity)
{
using (var client = new BinanceClient(highestBid.APIKey, highestBid.Secret))
{
var orderResult = client.PlaceOrder(highestBid.ExchangeType, OrderSide.Sell, OrderType.Limit, TimeInForce.ImmediateOrCancel, MinQuantity, highestBid.Ask);
return(new ExchangeApiData {
Stace = orderResult.Success, Msg = orderResult.Error.Message
});
}
}
public ExchangeData FindData(int exchangeID)
{
ExchangeData ed = null;
lock (this._GoodsExchangeDict)
{
this._GoodsExchangeDict.TryGetValue(exchangeID, out ed);
}
return(ed);
}
public async void WriteToClient(ExchangeData data)
{
var returnByteArr = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(data));
response.OutputStream.Write(returnByteArr, 0, returnByteArr.Length);
response.StatusCode = 200;
await response.OutputStream.FlushAsync();
response.Close();
}
/// <summary>
/// 交易所賣出
/// </summary>
/// <param name="highestBid">(賣價)最高資訊</param>
/// <param name="MinQuantity">數量</param>
/// <returns></returns>
internal ExchangeApiData PlaceOrderBid(ExchangeData highestBid, decimal MinQuantity)
{
using (var client = new BittrexClient(highestBid.APIKey, highestBid.Secret))
{
var placedOrder = client.PlaceOrder(OrderType.Sell, highestBid.ExchangeType, MinQuantity, highestBid.Ask);
return(new ExchangeApiData {
Stace = placedOrder.Success, Msg = placedOrder.Error.ErrorMessage
});
}
}
private static string CreateHtmlBody(SMSMessage callDetails, ExchangeData callerDetails)
{
var sb = new StringBuilder();
sb.AppendFormat("<h2>SMS From: {0}</h2>", callDetails.From);
sb.AppendFormat("<h3>Call Details</h3><table>");
sb.AppendFormat("<tr><td><b>{0}</b></td><td><h3>{1}</h3></td></tr>", "Message", callDetails.Body);
sb.AppendFormat("<tr><td><b>{0}</b></td><td>{1}, {2}</td></tr>", "Location", callerDetails.City, callerDetails.State );
sb.AppendFormat("<tr><td><b>{0}</b></td><td>{1}</td></tr>", "Recieved Time", callDetails.DateSent );
sb.AppendFormat("<tr><td><b>{0}</b></td><td>{1}</td></tr>", "Sent To Account", callDetails.To);
sb.AppendFormat("</table>");
return sb.ToString();
}
