/// <summary>
/// Handles object messages sent by bitmex.
/// </summary>
/// <param name="msg">The MSG.</param>
/// <param name="streams">The streams.</param>
/// <returns></returns>
public static bool HandleObjectMessage(string msg, BitmexClientStreams streams)
{
var response = BitmexJsonSerializer.Deserialize <JObject>(msg);
// ********************
// ADD OBJECT HANDLERS BELOW
// ********************
return
(TradeResponse.TryHandle(response, streams.TradesSubject) ||
TradeBinResponse.TryHandle(response, streams.TradeBinSubject) ||
BookResponse.TryHandle(response, streams.BookSubject) ||
QuoteResponse.TryHandle(response, streams.QuoteSubject) ||
LiquidationResponse.TryHandle(response, streams.LiquidationSubject) ||
PositionResponse.TryHandle(response, streams.PositionSubject) ||
MarginResponse.TryHandle(response, streams.MarginSubject) ||
OrderResponse.TryHandle(response, streams.OrderSubject) ||
WalletResponse.TryHandle(response, streams.WalletSubject) ||
InstrumentResponse.TryHandle(response, streams.InstrumentSubject) ||
ExecutionResponse.TryHandle(response, streams.ExecutionSubject) ||
FundingResponse.TryHandle(response, streams.FundingsSubject) ||
ErrorResponse.TryHandle(response, streams.ErrorSubject) ||
SubscribeResponse.TryHandle(response, streams.SubscribeSubject) ||
InfoResponse.TryHandle(response, streams.InfoSubject) ||
AuthenticationResponse.TryHandle(response, streams.AuthenticationSubject));
}
public QuoteResponse ProcessQuote(QuoteRequest request)
{
Console.WriteLine(string.Format("Processing quote for: {0}, product: {1}", request.Name, request.Product));
var response = new QuoteResponse()
{
Company = "Application 1",
Request = request
};
switch (request.Product)
{
case 2:
throw new ApplicationException("We do not support product 2");
case 4:
Thread.Sleep(new TimeSpan(0, 0, 0, 30));
response.Price = decimal.Zero;
break;
default:
response.Price = decimal.MaxValue;
break;
}
return(response);
}
public async Task<QuoteResponse> GetQuote(QuoteRequest request)
{
var client = this.ApiClient();
client.QueryString.Add ("pair", request.ExchangeMarketRef);
string rawData = await client.DownloadStringTaskAsync (this.QuoteApiUri);
var jsonData = JToken.Parse (rawData);
var quoteData = jsonData["result"][request.ExchangeMarketRef];
rawData = await client.DownloadStringTaskAsync (this.QuoteApiUri_OHLC);
jsonData = JToken.Parse (rawData);
var ohlcData = jsonData["result"][request.ExchangeMarketRef];
var quote = new QuoteResponse () {
ExchangeMarketCD = request.ExchangeMarketCD,
DailyOpen = Decimal.Parse(ohlcData[1].Value<string>()),
DailyHigh = Decimal.Parse(ohlcData[2].Value<string>()),
DailyLow = Decimal.Parse(ohlcData[3].Value<string>()),
DailyClose = Decimal.Parse(ohlcData[4].Value<string>()),
DailyVolume = Decimal.Parse(ohlcData[6].Value<string>()),
LastBid = Decimal.Parse(quoteData["b"][0].Value<string>()),
LastAsk = Decimal.Parse(quoteData["a"][0].Value<string>()),
LastTrade = Decimal.Parse(quoteData["c"][0].Value<string>()),
RawData = Encoding.ASCII.GetBytes (jsonData.ToString())
};
return quote;
}
public IEnumerable <dynamic> Return(QuoteResponse quote_response)
{
return
(csv_response_parser.ParseToLines(quote_response.WebResponse)
.Select(yahoo_quote => yahoo_quote_parser.Parse(yahoo_quote, quote_response.QuoteRequest.ReturnParameters))
.ToList());
}
public JsonResult SaveInstallments(QuoteResponse quoteResponse)
{
DateTime indianTime = TimeZoneInfo.ConvertTimeFromUtc(DateTime.UtcNow, INDIAN_ZONE);
quoteResponse.UpdatedDate = indianTime;
quoteResponse.Status = "Active";
if (quoteResponse.SecondInstallment == ",")
{
quoteResponse.SecondInstallment = "0,0";
}
if (quoteResponse.ThirdInstallment == ",")
{
quoteResponse.ThirdInstallment = "0,0";
}
if (quoteResponse.FourthInstallment == ",")
{
quoteResponse.FourthInstallment = "0,0";
}
if (quoteResponse.FifthInstallment == ",")
{
quoteResponse.FifthInstallment = "0,0";
}
int count = quotationListsService.AddInstallments(quoteResponse);
if (count > 0)
{
return(Json("Success"));
}
else
{
return(Json("Failed"));
}
}
public IEnumerable<dynamic> Return(QuoteResponse quote_response)
{
return
csv_response_parser.ParseToLines(quote_response.WebResponse)
.Select(yahoo_quote => yahoo_quote_parser.Parse(yahoo_quote, quote_response.QuoteRequest.ReturnParameters))
.ToList();
}
public static string showQuote(List <QuoteResponse> quoteList)
{
QuoteResponse quote = QuoteGenerate.QuotePickRand(quoteList);
Console.WriteLine(quote.Text);
return(quote.Text);
}
private bool HandleObjectMessage(string msg)
{
// ********************
// ADD OBJECT HANDLERS BELOW
// ********************
return
(ErrorResponse.TryHandle(msg, Streams.ErrorSubject) ||
SubscribeResponse.TryHandle(msg, Streams.SubscribeSubject) ||
BookResponse.TryHandle(msg, Streams.BookSubject) ||
TradeResponse.TryHandle(msg, Streams.TradesSubject) ||
QuoteResponse.TryHandle(msg, Streams.QuoteSubject) ||
LiquidationResponse.TryHandle(msg, Streams.LiquidationSubject) ||
PositionResponse.TryHandle(msg, Streams.PositionSubject) ||
MarginResponse.TryHandle(msg, Streams.MarginSubject) ||
OrderResponse.TryHandle(msg, Streams.OrderSubject) ||
WalletResponse.TryHandle(msg, Streams.WalletSubject) ||
ExecutionResponse.TryHandle(msg, Streams.ExecutionSubject) ||
FundingResponse.TryHandle(msg, Streams.FundingsSubject) ||
InstrumentResponse.TryHandle(msg, Streams.InstrumentSubject) ||
TradeBinResponse.TryHandle(msg, Streams.TradeBinSubject) ||
InfoResponse.TryHandle(msg, Streams.InfoSubject) ||
AuthenticationResponse.TryHandle(msg, Streams.AuthenticationSubject));
}
private bool HandleObjectMessage(string msg)
{
var response = BitmexJsonSerializer.Deserialize <JObject>(msg);
// ********************
// ADD OBJECT HANDLERS BELOW
// ********************
return
(TradeResponse.TryHandle(response, Streams.TradesSubject) ||
TradeBinResponse.TryHandle(response, Streams.TradeBinSubject) ||
BookResponse.TryHandle(response, Streams.BookSubject) ||
QuoteResponse.TryHandle(response, Streams.QuoteSubject) ||
LiquidationResponse.TryHandle(response, Streams.LiquidationSubject) ||
PositionResponse.TryHandle(response, Streams.PositionSubject) ||
OrderResponse.TryHandle(response, Streams.OrderSubject) ||
WalletResponse.TryHandle(response, Streams.WalletSubject) ||
ErrorResponse.TryHandle(response, Streams.ErrorSubject) ||
SubscribeResponse.TryHandle(response, Streams.SubscribeSubject) ||
InfoResponse.TryHandle(response, Streams.InfoSubject) ||
AuthenticationResponse.TryHandle(response, Streams.AuthenticationSubject));
}
private QuoteResponse CalculateOffer(GetQuoteRequest request)
{
var response = new QuoteResponse();
if (request.PropertyDetails.Cost / request.AccountDetails.AUM > 5)
{
response.DownPayment = 50000;
response.RateofInterest = "5.0%";
response.IsPreApproved = true;
}
else if (request.PropertyDetails.Cost / request.AccountDetails.AUM > 8)
{
response.DownPayment = 40000;
response.RateofInterest = "4.0%";
response.IsPreApproved = true;
}
else if (request.PropertyDetails.Cost / request.AccountDetails.AUM > 10)
{
response.DownPayment = 10000;
response.RateofInterest = "2.5%";
response.IsPreApproved = true;
}
else
{
response.IsPreApproved = false;
}
response.PropertyId = request.PropertyDetails.PropertyId;
response.UserId = request.AccountDetails.UserId;
response.AccountNumber = request.AccountDetails.AccountNumber;
response.MonthlyEMI = (request.PropertyDetails.Cost - response.DownPayment) / 240;
return(response);
}
public StockQuote(int stockId)
{
Quote = new QuoteResponse();
Quote.QuoteData = new QuoteData();
Quote.QuoteData.All = new All();
Quote.QuoteData.Product = new Product();
Quote.QuoteData.Product.StockId = stockId;
}
public ActionResult DeleteConfirmed(int id)
{
QuoteResponse quoteResponse = db.QuoteResponses.Find(id);
db.QuoteResponses.Remove(quoteResponse);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public static void Main(string[] args)
{
var port = 3000;
var address = "127.0.0.1";
var requestSerializer = new XmlSerializer(typeof(QuoteRequest));
var responseSerializer = new XmlSerializer(typeof(QuoteResponse));
string directoryPath = @"C:\Users\ftd-04\source\repos\dotnet-rest-controller-assignment-LucasJenkins\dotnet-io-concurrency-assignment-LucasJenkins\Files";
// Example QuoteRequest containing symbols and fields client wishes to fetch data about
var request = new QuoteRequest();
Console.WriteLine("Please specify interval between 1-10, followed by 3 request, followed by 3 companies");
foreach (var x in args)
{
switch (args)
{
case:
request.
case:
break;
case:
break;
case:
break
}
}
try
{
// Initialize connection to server
var client = new TcpClient(address, port);
using (var stream = client.GetStream())
{
// Serialize request to server
requestSerializer.Serialize(stream, request);
// Temporary hacky fix for data preventing read blocking
client.Client.Shutdown(SocketShutdown.Send);
// Receive QuoteResponse from server
QuoteResponse response = (QuoteResponse)responseSerializer.Deserialize(stream);
File.WriteAllText(directoryPath, response.QuoteString);
}
}
catch (IOException e)
{
Console.WriteLine(e.Message);
}
}
public string Get()
{
QuoteResponse response = new QuoteResponse()
{
HouseCost = 25000000, IsPreapproved = true, RateofInterest = "2.40"
};
var jsonresponse = Newtonsoft.Json.JsonConvert.SerializeObject(response);
return(jsonresponse);
}
public ActionResult Edit([Bind(Include = "QuoteReposonseId,QuoteCostPerItem,QuoteCostTotal,Notes,QuoteRequestId")] QuoteResponse quoteResponse)
{
if (ModelState.IsValid)
{
db.Entry(quoteResponse).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.QuoteReposonseId = new SelectList(db.QuoteRequests, "QuoteRequestId", "SpecificationDetails", quoteResponse.QuoteReposonseId);
return(View(quoteResponse));
}
// GET: QuoteResponses/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
QuoteResponse quoteResponse = db.QuoteResponses.Find(id);
if (quoteResponse == null)
{
return(HttpNotFound());
}
return(View(quoteResponse));
}
public static void Main(string[] args)
{
var port = 3000;
var address = "127.0.0.1";
var requestSerializer = new XmlSerializer(typeof(QuoteRequest));
var responseSerializer = new XmlSerializer(typeof(QuoteResponse));
//string filename = "C:\\Users\ftd-09\\Desktop\\Ticker.xml";
// Example QuoteRequest containing symbols and fields client wishes to fetch data about
var request = new QuoteRequest
{
Fields = new List <QuoteField> {
QuoteField.High, QuoteField.Low, QuoteField.Close
},
Symbols = new List <string> {
"AAPL", "TSLA", "TWTR", "SNAP", "GOOGL", "AMZN"
},
Interval = 10000
};
try
{
while (true)
{
// Initialize connection to server
var client = new TcpClient(address, port);
using (var stream = client.GetStream())
{
// Serialize request to server
requestSerializer.Serialize(stream, request);
// Temporary hacky fix for data preventing read blocking
client.Client.Shutdown(SocketShutdown.Send);
// Receive QuoteResponse from server
QuoteResponse response = (QuoteResponse)responseSerializer.Deserialize(stream);
stream.CopyTo(Console.OpenStandardOutput());
}
}
}
catch (IOException e)
{
Console.WriteLine(e.Message);
}
}
public string Post(GetQuoteRequest request)
{
var response = new QuoteResponse();
var IseverythingAlright = Validate(request);
if (!IseverythingAlright)
{
return("Please check input parameters, Something is not right!");
}
response = CalculateOffer(request);
var jsonresponse = Newtonsoft.Json.JsonConvert.SerializeObject(response);
return(jsonresponse);
}
// GET: QuoteResponses/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
QuoteResponse quoteResponse = db.QuoteResponses.Find(id);
if (quoteResponse == null)
{
return(HttpNotFound());
}
ViewBag.QuoteReposonseId = new SelectList(db.QuoteRequests, "QuoteRequestId", "SpecificationDetails", quoteResponse.QuoteReposonseId);
return(View(quoteResponse));
}
public static OrderTotals GetQuote(Order order, OrderTotals total, bool calcFreight)
{
var order_V01 = order as Order_V01;
var request = new QuoteRequest_V02 {
Order = order_V01, CalcFreight = calcFreight, Donation = (total as OrderTotals_V02) == null ? decimal.Zero : (total as OrderTotals_V02).Donation
};
var session = SessionInfo.GetSessionInfo(order.DistributorID, CultureInfo.CurrentCulture.Name);
if (null != session)
{
SessionInfo.GetSessionInfo(order.DistributorID, CultureInfo.CurrentCulture.Name).HmsPricing = HLConfigManager.Configurations.CheckoutConfiguration.UseHMSCalc;
}
order.DistributorID = order.DistributorID.ToUpper();
if (Settings.GetRequiredAppSetting("LogCatalogCN", "false").ToLower() == "true")
{
LogRequest(OrderCreationHelper.Serialize(request));
}
QuoteResponse result = null;
var proxy = ServiceClientProvider.GetOrderServiceProxy();
try
{
result = proxy.Quote(new QuoteRequest1(request)).QuoteResult;
if (result.Status == ServiceResponseStatusType.Success && result.Totals != null)
{
if (Settings.GetRequiredAppSetting("LogCatalogCN", "false").ToLower() == "true")
{
LogRequest(OrderCreationHelper.Serialize(result));
}
return(result.Totals);
}
else
{
LoggerHelper.Error(
string.Format(
"Order Total error, distributor:{0} receive date:{1}, Calc Freight :{3}, error message:{2}",
order.DistributorID, order_V01.ReceivedDate.ToString(), order_V01.Messages, calcFreight));
}
}
catch (Exception ex)
{
LoggerHelper.Error(
string.Format(
"Order Total error, distributor:{0} receive date:{1}, Calc Freight:{3}, error message:{2}",
order.DistributorID, order_V01.ReceivedDate.ToString(), ex, calcFreight));
}
return(null);
}
public async Task<QuoteResponse> GetQuote(QuoteRequest request)
{
var client = this.ApiClient();
string rawData = await client.DownloadStringTaskAsync (this.QuoteApiUri);
var jsonData = JToken.Parse (rawData);
var quote = new QuoteResponse () {
ExchangeMarketCD = request.ExchangeMarketCD,
LastBid = Decimal.Parse(jsonData["buy_price"].Value<string>()),
LastAsk = Decimal.Parse(jsonData["sell_price"].Value<string>()),
LastTrade = Decimal.Parse(jsonData["remit_partner_price"].Value<string>()),
RawData = Encoding.ASCII.GetBytes (jsonData.ToString())
};
return quote;
}
public async Task<QuoteResponse> GetQuote(QuoteRequest request)
{
var client = this.ApiClient();
string rawData = await client.DownloadStringTaskAsync (this.QuoteApiUri);
var jsonData = JToken.Parse (rawData);
var quote = new QuoteResponse () {
ExchangeMarketCD = request.ExchangeMarketCD,
LastTrade = Decimal.Parse(jsonData["last"]["value"].Value<string>()),
ReportedTime = DateTimeOffset.Parse(jsonData["last"]["timestamp"].Value<string>(),
CultureInfo.InvariantCulture.DateTimeFormat,
DateTimeStyles.AssumeUniversal),
RawData = Encoding.ASCII.GetBytes (jsonData.ToString())
};
return quote;
}
public async Task<QuoteResponse> GetQuote(QuoteRequest request)
{
var client = this.ApiClient();
client.QueryString.Add ("token", request.ApiToken);
string rawData = await client.DownloadStringTaskAsync (this.QuoteApiUri);
var jsonData = JToken.Parse (rawData);
var quote = new QuoteResponse () {
ExchangeMarketCD = request.ExchangeMarketCD,
LastBid = Decimal.Parse(jsonData["PHP"].Value<string>()),
LastAsk = Decimal.Parse(jsonData["PHP-ASK"].Value<string>()),
RawData = Encoding.ASCII.GetBytes (jsonData.ToString())
};
return quote;
}
public async Task<QuoteResponse> GetQuote(QuoteRequest request)
{
var client = this.ApiClient();
client.QueryString.Add ("amount", "1");
client.QueryString.Add ("curr", request.ExchangeMarketRef.Substring(0, 3));
client.QueryString.Add ("refCurr", request.ExchangeMarketRef.Substring(3, 3));
string rawData = await client.DownloadStringTaskAsync (this.QuoteApiUri);
var jsonData = JToken.Parse (rawData);
var quote = new QuoteResponse () {
ExchangeMarketCD = request.ExchangeMarketCD,
LastTrade = Decimal.Parse(jsonData["rate"].Value<string>()),
RawData = Encoding.ASCII.GetBytes (jsonData.ToString())
};
return quote;
}
public QuoteResponse ProcessQuote(QuoteRequest request)
{
Console.WriteLine(string.Format("Processing quote for: {0}, product: {1}", request.Name, request.Product));
var response = new QuoteResponse()
{
Company = "Application 4",
Request = request
};
switch (request.Product)
{
default:
response.Price = decimal.MaxValue;
break;
}
return(response);
}
public static async Task <List <StockModel> > GetStockDetails(List <string> symbolStringList)
{
var client = new HttpClient();
StringBuilder sb = new StringBuilder();
string baseUri = @"https://yahoo-finance-low-latency.p.rapidapi.com/v6/finance/quote?symbols=";
string symbolsUri = String.Join("%2C", symbolStringList);
sb.Append(baseUri);
sb.Append(symbolsUri);
string uri = sb.ToString();
var apiKey = ConfigurationManager.AppSettings["x-rapidapi-key"];
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri(uri),
Headers =
{
{ "x-rapidapi-key", apiKey },
{ "x-rapidapi-host", "yahoo-finance-low-latency.p.rapidapi.com" },
},
};
using (HttpResponseMessage response = client.SendAsync(request).Result)
{
QuoteResponse stocks = new QuoteResponse();
if (response.IsSuccessStatusCode)
{
StockApiResponse result = await response.Content.ReadAsAsync <StockApiResponse>();
stocks = result.QuoteResponse;
}
else
{
throw new HttpRequestException(response.ReasonPhrase);
}
return(stocks.Result.ToList());
}
}
public async Task<QuoteResponse> GetQuote(QuoteRequest request)
{
var client = this.ApiClient();
client.QueryString.Add ("currencypair", request.ExchangeMarketRef);
string rawData = await client.DownloadStringTaskAsync (this.QuoteApiUri);
var jsonData = JToken.Parse (rawData);
this.CheckResponse (jsonData);
var quoteData = jsonData["quote"];
var quote = new QuoteResponse () {
ExchangeMarketCD = request.ExchangeMarketCD,
LastBid = Decimal.Parse(quoteData["bid"].Value<string>()),
LastAsk = Decimal.Parse(quoteData["ask"].Value<string>()),
RawData = Encoding.ASCII.GetBytes (jsonData.ToString())
};
return quote;
}
/// <summary>
/// Events
/// </summary>
private void OnQuoteResponse(QuoteResponse cmd)
{
ThreadPool.QueueUserWorkItem(o =>
{
try
{
if (TickArrived == null)
{
return;
}
TickArrived(new Tick(cmd.quote.symbol, DateTime.Now, (decimal)cmd.quote.last));
}
catch (Exception e)
{
if (InfoChanged != null)
{
InfoChanged(e.Message + Environment.NewLine + e.StackTrace);
}
}
});
}
public IActionResult Post([FromBody] Quote quote)
{
if (
quote.Country != "FR" ||
(quote.ReturnDate - quote.DepartureDate).Days < 7 ||
(quote.Options != null && quote.Options.Any()) ||
quote.Cover != "BASIC" ||
(quote.TravellerAges != null && quote.TravellerAges.Any(a => a < 66))
)
{
return(this.BadRequest());
}
var quoteResponse = new QuoteResponse();
quoteResponse.Quote =
1.8m *
1m *
quote.TravellerAges.Sum() * 1.5m *
(quote.ReturnDate - quote.DepartureDate).Days;
return(this.Ok(quoteResponse));
}
private static async Task ClientHandlerAsync(TcpClient client, XmlSerializer requestSerializer, XmlSerializer responseSerializer)
{
using (NetworkStream stream = client.GetStream())
{
// Deserialize QuoteRequest
var request = (QuoteRequest)requestSerializer.Deserialize(stream);
// Fetch quotes from stock API
Console.WriteLine("Fetching quotes");
var quotes = await Stocks.Api.FetchQuotes(request);
// Convert response into formatted string
var quoteString = new QuoteResponse
{
QuoteString = Stocks.Utils.QuotesToString(quotes, request.Fields)
};
// Serialize response back to client
Console.WriteLine("Sending quote");
responseSerializer.Serialize(stream, quoteString);
}
}
public async Task<QuoteResponse> GetQuote(QuoteRequest request)
{
var client = this.ApiClient();
client.QueryString.Add ("book", request.ExchangeMarketRef);
string rawData = await client.DownloadStringTaskAsync (this.QuoteApiUri);
var jsonData = JToken.Parse (rawData);
var quote = new QuoteResponse () {
ExchangeMarketCD = request.ExchangeMarketCD,
DailyHigh = Decimal.Parse(jsonData["high"].Value<string>()),
DailyLow = Decimal.Parse(jsonData["low"].Value<string>()),
DailyVolume = Decimal.Parse(jsonData["volume"].Value<string>()),
LastBid = Decimal.Parse(jsonData["bid"].Value<string>()),
LastAsk = Decimal.Parse(jsonData["ask"].Value<string>()),
LastTrade = Decimal.Parse(jsonData["last"].Value<string>()),
ReportedTime = Utilities.GetDateTimeFromUnixTimestamp (jsonData["timestamp"].Value<long> ()),
RawData = Encoding.ASCII.GetBytes (jsonData.ToString())
};
return quote;
}
public QuoteResponse GetQuoteResponse(int?id)
{
QuoteResponse response = new QuoteResponse();
if (id != null)
{
response.Quote = quoteRepository.GetQuoteAndQuoteDetail((int)id);
}
else
{
response.QuoteCount = quoteRepository.GetAll().Count() + 1;
}
//BaseData
response.Contacts = contactRepository.GetAll().ToList();
response.Products = productRepository.GetAll().ToList();
response.ProductModels = productModelRepository.GetAll().ToList();
response.Exclusions = exclusionRepository.GetAll().ToList();
return(response);
}
public async Task<QuoteResponse> GetQuote(QuoteRequest request)
{
var client = this.ApiClient();
client.QueryString.Add ("currencypair", request.ExchangeMarketRef);
string rawData = await client.DownloadStringTaskAsync (this.QuoteApiUri);
var jsonData = JToken.Parse (rawData);
var quoteData = jsonData["ticker"][request.ExchangeMarketRef];
var quote = new QuoteResponse () {
ExchangeMarketCD = request.ExchangeMarketCD,
DailyVolume = Decimal.Parse(quoteData["volume"].Value<string>()),
DailyHigh = Decimal.Parse(quoteData["high"].Value<string>()),
DailyLow = Decimal.Parse(quoteData["low"].Value<string>()),
LastBid = Decimal.Parse(quoteData["buy"].Value<string>()),
LastAsk = Decimal.Parse(quoteData["sell"].Value<string>()),
LastTrade = Decimal.Parse(quoteData["last"].Value<string>()),
RawData = Encoding.ASCII.GetBytes (jsonData.ToString())
};
return quote;
}
public QuoteResponse GetQuote()
{
var values = new List <string>();
var requestUrl = ConfigurationManager.AppSettings.Get(Constants.QuoteServiceUrl);
var request = WebRequest.Create(requestUrl);
var result = new QuoteResponse();
request.Method = "GET";
var response = request.GetResponse();
var dataStream = response.GetResponseStream();
StreamReader reader = new StreamReader(dataStream);
string responseFromServer = reader.ReadToEnd();
JavaScriptSerializer javascriptSerializer = new JavaScriptSerializer();
values = javascriptSerializer.Deserialize <List <string> >(responseFromServer);
result.Values = values;
return(result);
}
public async Task<QuoteResponse> GetQuote(QuoteRequest request)
{
var client = this.ApiClient();
var endpointUri = new Uri (
this.QuoteApiUri,
this.QuoteApiUri.AbsolutePath.Replace("$$", request.ExchangeMarketRef)
);
string signature = this.GenerateRequestSignature(
request.ApiSecret,
endpointUri.AbsolutePath,
client.QueryString
);
client.Headers.Add ("Rest-Key", request.ApiToken);
client.Headers.Add ("Rest-Sign", signature);
string rawData = await client.DownloadStringTaskAsync (endpointUri);
var jsonData = JToken.Parse (rawData);
var quoteData = jsonData["data"];
var quote = new QuoteResponse () {
ExchangeMarketCD = request.ExchangeMarketCD,
DailyAverage = Decimal.Parse(quoteData["avg"]["value"].Value<string>()),
DailyVolume = Decimal.Parse(quoteData["vol"]["value"].Value<string>()),
DailyHigh = Decimal.Parse(quoteData["high"]["value"].Value<string>()),
DailyLow = Decimal.Parse(quoteData["low"]["value"].Value<string>()),
LastBid = Decimal.Parse(quoteData["buy"]["value"].Value<string>()),
LastAsk = Decimal.Parse(quoteData["sell"]["value"].Value<string>()),
LastTrade = Decimal.Parse(quoteData["last"]["value"].Value<string>()),
RawData = Encoding.ASCII.GetBytes (jsonData.ToString()),
ReportedTime = Utilities.GetDateTimeFromUnixTimestamp (quoteData ["dataUpdateTime"].Value<long> () / 1000000)
};
return quote;
}
private QuoteResponse ErrorQuoteResponse(string reason)
{
_logger.LogInformation($"Invalid quote request: {reason}");
return(QuoteResponse.Error(reason));
}
public int AddInstallments(QuoteResponse quoteResponse)
{
return(quotationListsRepository.AddInstallments(quoteResponse));
}
public int AddInstallments(QuoteResponse quoteResponse)
{
_dbContext.QuoteResponse.Add(quoteResponse);
_dbContext.SaveChanges();
return(1);
}
public virtual void onMessage(QuoteResponse message, QuickFix.SessionID session)
{
throw new QuickFix.UnsupportedMessageType();
}
private async Task <QuoteResponse> GenerateQuote(GetQuoteRequest requestQuote, string previousOperationId)
{
var settings = _liquidityConverterSettingsAccessor.GetLiquidityConverterSettings(requestQuote.BrokerId);
if (settings == null)
{
return(ErrorQuoteResponse("Liquidity Converter is not configured for broker"));
}
var processQuoteResult =
_instrumentEngine.ProcessQuoteRequest(requestQuote, settings.MarkUp);
if (!string.IsNullOrWhiteSpace(processQuoteResult.ErrorMessage))
{
return(ErrorQuoteResponse(processQuoteResult.ErrorMessage));
}
// todo: calculate fee
//var finalPrice = (1 + settings.MarkUp + fee) * price;
//finalPrice = Math.Round(finalPrice, Mathematics.AccuracyToNormalizeDouble);
//finalPrice = Math.Round(finalPrice, instrument.Accuracy, MidpointRounding.ToZero);
var operationId = Guid.NewGuid().ToString("N");
var quote = new ConvertQuote(requestQuote.FromAsset,
requestQuote.ToAsset,
processQuoteResult.FromAssetVolume,
processQuoteResult.ToAssetVolume,
requestQuote.IsFromFixed,
requestQuote.BrokerId,
requestQuote.AccountId,
requestQuote.WalletId,
previousOperationId
)
{
Price = processQuoteResult.Price,
OperationId = operationId
};
var now = DateTime.UtcNow;
quote.ExpireDate = now.AddSeconds(settings.ExpirationInSeconds);
quote.OpenDate = DateTime.UtcNow;
quote.ClosedDate = DateTime.MinValue;
quote.State = QuoteState.Active;
// todo: добавить контекст формирования квоты - orderSide, instrumentS, fee
await _convertQuoteStorage.SaveAsync(quote);
processQuoteResult.Instruments.ForEach(async instrumentInTrade =>
{
await _convertQuoteStorage.SaveAsync(new Trade()
{
TradeId = Guid.NewGuid().ToString("N"),
OperationId = operationId,
Fee = 0.0, // todo: calculate fee
MarkUp = settings.MarkUp,
InstrumentSymbol = instrumentInTrade.Symbol,
InstrumentPrice = instrumentInTrade.Price,
State = TradeState.New
});
});
// we send to client short interval and keep on server long interval
quote.ExpireDate = now.AddSeconds(settings.ClientExpirationInSeconds);
return(QuoteResponse.Success(quote));
}
