/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='request'>
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <object> GetCandlesHistoryBatchOrErrorAsync(this ICandleshistoryservice operations, GetCandlesHistoryBatchRequest request = default(GetCandlesHistoryBatchRequest), CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.GetCandlesHistoryBatchOrErrorWithHttpMessagesAsync(request, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='request'>
/// </param>
public static object GetCandlesHistoryBatchOrError(this ICandleshistoryservice operations, GetCandlesHistoryBatchRequest request = default(GetCandlesHistoryBatchRequest))
{
return(operations.GetCandlesHistoryBatchOrErrorAsync(request).GetAwaiter().GetResult());
}
public async Task <IActionResult> GetCandlesHistoryBatch([FromBody] GetCandlesHistoryBatchRequest request, CancellationToken cancellationToken)
{
if (!ModelState.IsValid)
{
return(Ok(new Dictionary <string, CandlesHistoryResponseModel>()));
}
if (cancellationToken.IsCancellationRequested || request.AssetPairs == null || !request.AssetPairs.Any())
{
return(Ok(new Dictionary <string, CandlesHistoryResponseModel>()));
}
request.FromMoment = request.FromMoment.ToUniversalTime();
request.ToMoment = request.ToMoment.ToUniversalTime();
if (request.PriceType == CandlePriceType.Unspecified)
{
return(BadRequest(ErrorResponse.Create(nameof(request.PriceType), $"Price type should not be {CandlePriceType.Unspecified}")));
}
if (request.TimeInterval == CandleTimeInterval.Unspecified)
{
return(BadRequest(ErrorResponse.Create(nameof(request.TimeInterval), $"Time interval should not be {CandleTimeInterval.Unspecified}")));
}
if (request.FromMoment > request.ToMoment)
{
return(BadRequest(ErrorResponse.Create("From date should be early or equal than To date")));
}
var notConfiguerdAssetPairs = request.AssetPairs
.Where(p => !_candleHistoryAssetConnections.ContainsKey(p))
.ToArray();
if (notConfiguerdAssetPairs.Any())
{
return(BadRequest(
ErrorResponse.Create(nameof(request.AssetPairs),
$"Asset pairs [{string.Join(", ", notConfiguerdAssetPairs)}] are not configured")));
}
var assetPairsTask = request.AssetPairs.Select(p => _assetPairsManager.TryGetAssetPairAsync(p)).ToArray();
await Task.WhenAll(assetPairsTask);
if (assetPairsTask.Any(t => t.Result == null))
{
var notFound = request.AssetPairs.Except(assetPairsTask.Select(p => p.Result?.Id).Where(p => p != null));
return(BadRequest(
ErrorResponse.Create(nameof(request.AssetPairs),
$"Asset pairs [{string.Join(", ", notFound)}] are not found")));
}
var allHistory = new Dictionary <string, CandlesHistoryResponseModel>();
var tasks = new List <Task <IEnumerable <ICandle> > >();
var activeSlot = await _candlesManager.GetActiveSlotAsync();
foreach (var assetPair in request.AssetPairs)
{
allHistory[assetPair] = new CandlesHistoryResponseModel {
History = Array.Empty <CandlesHistoryResponseModel.Candle>()
};
tasks.Add(_candlesManager.GetCandlesAsync(assetPair, request.PriceType, request.TimeInterval, request.FromMoment, request.ToMoment, activeSlot));
}
await Task.WhenAll(tasks);
foreach (var task in tasks)
{
var candles = task.Result.Select(c => new
{
pair = c.AssetPairId,
model = new CandlesHistoryResponseModel.Candle
{
DateTime = c.Timestamp,
Open = c.Open,
Close = c.Close,
High = c.High,
Low = c.Low,
TradingVolume = c.TradingVolume,
TradingOppositeVolume = c.TradingOppositeVolume,
LastTradePrice = c.LastTradePrice
}
}).ToArray();
if (candles.Any())
{
var p = candles[0].pair;
allHistory[p] = new CandlesHistoryResponseModel {
History = candles.Select(c => c.model)
};
}
}
return(Ok(allHistory));
}
public IResponse PostCandlesHistoryBatch(GetCandlesHistoryBatchRequest model)
{
return(Request.Post("/CandlesHistory/batch").AddJsonBody(model).Build().Execute());
}
/// <param name='request'>
/// </param>
/// <param name='customHeaders'>
/// Headers that will be added to request.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
/// <exception cref="HttpOperationException">
/// Thrown when the operation returned an invalid status code
/// </exception>
/// <exception cref="SerializationException">
/// Thrown when unable to deserialize the response
/// </exception>
/// <return>
/// A response object containing the response body and response headers.
/// </return>
public async Task <HttpOperationResponse <object> > GetCandlesHistoryBatchOrErrorWithHttpMessagesAsync(GetCandlesHistoryBatchRequest request = default(GetCandlesHistoryBatchRequest), Dictionary <string, List <string> > customHeaders = null, CancellationToken cancellationToken = default(CancellationToken))
{
if (request != null)
{
request.Validate();
}
// Tracing
bool _shouldTrace = ServiceClientTracing.IsEnabled;
string _invocationId = null;
if (_shouldTrace)
{
_invocationId = ServiceClientTracing.NextInvocationId.ToString();
Dictionary <string, object> tracingParameters = new Dictionary <string, object>();
tracingParameters.Add("request", request);
tracingParameters.Add("cancellationToken", cancellationToken);
ServiceClientTracing.Enter(_invocationId, this, "GetCandlesHistoryBatchOrError", tracingParameters);
}
// Construct URL
var _baseUrl = BaseUri.AbsoluteUri;
var _url = new System.Uri(new System.Uri(_baseUrl + (_baseUrl.EndsWith("/") ? "" : "/")), "api/CandlesHistory/batch").ToString();
// Create HTTP transport objects
var _httpRequest = new HttpRequestMessage();
HttpResponseMessage _httpResponse = null;
_httpRequest.Method = new HttpMethod("POST");
_httpRequest.RequestUri = new System.Uri(_url);
// Set Headers
if (customHeaders != null)
{
foreach (var _header in customHeaders)
{
if (_httpRequest.Headers.Contains(_header.Key))
{
_httpRequest.Headers.Remove(_header.Key);
}
_httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
}
}
// Serialize Request
string _requestContent = null;
if (request != null)
{
_requestContent = SafeJsonConvert.SerializeObject(request, SerializationSettings);
_httpRequest.Content = new StringContent(_requestContent, System.Text.Encoding.UTF8);
_httpRequest.Content.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json-patch+json; charset=utf-8");
}
// Send Request
if (_shouldTrace)
{
ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
}
cancellationToken.ThrowIfCancellationRequested();
_httpResponse = await HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
if (_shouldTrace)
{
ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
}
HttpStatusCode _statusCode = _httpResponse.StatusCode;
cancellationToken.ThrowIfCancellationRequested();
string _responseContent = null;
if ((int)_statusCode != 200 && (int)_statusCode != 400)
{
var ex = new HttpOperationException(string.Format("Operation returned an invalid status code '{0}'", _statusCode));
if (_httpResponse.Content != null)
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
}
else
{
_responseContent = string.Empty;
}
ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
if (_shouldTrace)
{
ServiceClientTracing.Error(_invocationId, ex);
}
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw ex;
}
// Create Result
var _result = new HttpOperationResponse <object>();
_result.Request = _httpRequest;
_result.Response = _httpResponse;
// Deserialize Response
if ((int)_statusCode == 200)
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
try
{
_result.Body = SafeJsonConvert.DeserializeObject <IDictionary <string, CandlesHistoryResponseModel> >(_responseContent, DeserializationSettings);
}
catch (JsonException ex)
{
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw new SerializationException("Unable to deserialize the response.", _responseContent, ex);
}
}
// Deserialize Response
if ((int)_statusCode == 400)
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
try
{
_result.Body = SafeJsonConvert.DeserializeObject <ErrorResponse>(_responseContent, DeserializationSettings);
}
catch (JsonException ex)
{
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw new SerializationException("Unable to deserialize the response.", _responseContent, ex);
}
}
if (_shouldTrace)
{
ServiceClientTracing.Exit(_invocationId, _result);
}
return(_result);
}
