/// <summary>
/// Deserialize JSON and raise <see cref="UserDataEventArgs"/> event.
/// </summary>
/// <param name="json"></param>
/// <param name="token"></param>
/// <param name="callback"></param>
/// <returns></returns>
protected override void DeserializeJsonAndRaiseEvent(string json, CancellationToken token, Action <UserDataEventArgs> callback = null)
{
Throw.IfNullOrWhiteSpace(json, nameof(json));
Logger?.LogDebug($"{nameof(UserDataWebSocketClient)}: \"{json}\"");
try
{
var jObject = JObject.Parse(json);
var eventType = jObject["e"].Value <string>();
var eventTime = jObject["E"].Value <long>();
// ReSharper disable once ConvertIfStatementToSwitchStatement
if (eventType == "outboundAccountInfo")
{
var commissions = new AccountCommissions(
jObject["m"].Value <int>(), // maker
jObject["t"].Value <int>(), // taker
jObject["b"].Value <int>(), // buyer
jObject["s"].Value <int>()); // seller
var status = new AccountStatus(
jObject["T"].Value <bool>(), // can trade
jObject["W"].Value <bool>(), // can withdraw
jObject["D"].Value <bool>()); // can deposit
var balances = jObject["B"]
.Select(entry => new AccountBalance(
entry["a"].Value <string>(), // asset
entry["f"].Value <decimal>(), // free amount
entry["l"].Value <decimal>())) // locked amount
.ToList();
var eventArgs = new AccountUpdateEventArgs(eventTime, token, new AccountInfo(User, commissions, status, jObject["u"].Value <long>(), balances));
try
{
callback?.Invoke(eventArgs);
AccountUpdate?.Invoke(this, eventArgs);
}
catch (OperationCanceledException) { }
catch (Exception e)
{
if (!token.IsCancellationRequested)
{
Logger?.LogError(e, $"{nameof(UserDataWebSocketClient)}: Unhandled account update event handler exception.");
}
}
}
else if (eventType == "executionReport")
{
var order = new Order(User);
FillOrder(order, jObject);
var executionType = ConvertOrderExecutionType(jObject["x"].Value <string>());
var rejectedReason = ConvertOrderRejectedReason(jObject["r"].Value <string>());
var newClientOrderId = jObject["c"].Value <string>();
if (executionType == OrderExecutionType.Trade) // trade update event.
{
var trade = new AccountTrade(
jObject["s"].Value <string>(), // symbol
jObject["t"].Value <long>(), // ID
jObject["i"].Value <long>(), // order ID
jObject["L"].Value <decimal>(), // price (price of last filled trade)
jObject["z"].Value <decimal>(), // quantity (accumulated quantity of filled trades)
jObject["n"].Value <decimal>(), // commission
jObject["N"].Value <string>(), // commission asset
jObject["T"].Value <long>(), // timestamp
order.Side == OrderSide.Buy, // is buyer
jObject["m"].Value <bool>(), // is buyer maker
jObject["M"].Value <bool>()); // is best price
var quantityOfLastFilledTrade = jObject["l"].Value <decimal>();
var eventArgs = new AccountTradeUpdateEventArgs(eventTime, token, order, rejectedReason, newClientOrderId, trade, quantityOfLastFilledTrade);
try
{
callback?.Invoke(eventArgs);
TradeUpdate?.Invoke(this, eventArgs);
}
catch (OperationCanceledException) { }
catch (Exception e)
{
if (!token.IsCancellationRequested)
{
Logger?.LogError(e, $"{nameof(UserDataWebSocketClient)}: Unhandled trade update event handler exception.");
}
}
}
else // order update event.
{
var eventArgs = new OrderUpdateEventArgs(eventTime, token, order, executionType, rejectedReason, newClientOrderId);
try
{
callback?.Invoke(eventArgs);
OrderUpdate?.Invoke(this, eventArgs);
}
catch (OperationCanceledException) { }
catch (Exception e)
{
if (!token.IsCancellationRequested)
{
Logger?.LogError(e, $"{nameof(UserDataWebSocketClient)}: Unhandled order update event handler exception.");
}
}
}
}
else
{
Logger?.LogWarning($"{nameof(UserDataWebSocketClient)}.{nameof(DeserializeJsonAndRaiseEvent)}: Unexpected event type ({eventType}) - \"{json}\"");
}
}
catch (OperationCanceledException) { }
catch (Exception e)
{
if (!token.IsCancellationRequested)
{
Logger?.LogError(e, $"{nameof(UserDataWebSocketClient)}.{nameof(DeserializeJsonAndRaiseEvent)}");
}
}
}
/// <summary>
/// Update This updates the entity with the given properties. Only those properties which should be updated can be provided. The 'id' and 'version' are required to identify the entity.
/// </summary>
/// <exception cref="PostFinanceCheckout.Client.ApiException">Thrown when fails to make API call</exception>
/// <param name="entity">The account object with all the properties which should be updated. The id and the version are required properties.</param>
/// <returns>ApiResponse of Account</returns>
public ApiResponse <Account> UpdateWithHttpInfo(AccountUpdate entity)
{
// verify the required parameter 'entity' is set
if (entity == null)
{
throw new ApiException(400, "Missing required parameter 'entity' when calling AccountService->Update");
}
var localVarPath = "/account/update";
var localVarPathParams = new Dictionary <String, String>();
var localVarQueryParams = new List <KeyValuePair <String, String> >();
var localVarHeaderParams = new Dictionary <String, String>(this.Configuration.DefaultHeader);
var localVarFormParams = new Dictionary <String, String>();
var localVarFileParams = new Dictionary <String, FileParameter>();
Object localVarPostBody = null;
// to determine the Content-Type header
String[] localVarHttpContentTypes = new String[] {
"application/json;charset=utf-8"
};
String localVarHttpContentType = this.Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);
// to determine the Accept header
String[] localVarHttpHeaderAccepts = new String[] {
"application/json;charset=utf-8"
};
String localVarHttpHeaderAccept = this.Configuration.ApiClient.SelectHeaderAccept(localVarHttpHeaderAccepts);
if (localVarHttpHeaderAccept != null)
{
localVarHeaderParams.Add("Accept", localVarHttpHeaderAccept);
}
if (entity != null && entity.GetType() != typeof(byte[]))
{
localVarPostBody = this.Configuration.ApiClient.Serialize(entity); // http body (model) parameter
}
else
{
localVarPostBody = entity; // byte array
}
this.Configuration.ApiClient.ResetTimeout();
// make the HTTP request
IRestResponse localVarResponse = (IRestResponse)this.Configuration.ApiClient.CallApi(localVarPath,
Method.POST, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams, localVarFileParams,
localVarPathParams, localVarHttpContentType);
int localVarStatusCode = (int)localVarResponse.StatusCode;
if (ExceptionFactory != null)
{
Exception exception = ExceptionFactory("Update", localVarResponse);
if (exception != null)
{
throw exception;
}
}
return(new ApiResponse <Account>(localVarStatusCode,
localVarResponse.Headers.ToDictionary(x => x.Name, x => x.Value.ToString()),
(Account)this.Configuration.ApiClient.Deserialize(localVarResponse, typeof(Account))));
}
protected override void HandleMessage(IEnumerable <Action <UserDataEventArgs> > callbacks, string stream, string json)
{
if (!Users.ContainsKey(stream))
{
Logger?.LogError($"{nameof(UserDataClient)}.{nameof(HandleMessage)}: Unknown listen key (\"{stream}\"). [thread: {Thread.CurrentThread.ManagedThreadId}]");
return; // ignore.
}
var user = Users[stream];
try
{
var jObject = JObject.Parse(json);
var eventType = jObject["e"].Value <string>();
var eventTime = jObject["E"].Value <long>().ToDateTime();
// ReSharper disable once ConvertIfStatementToSwitchStatement
if (eventType == "outboundAccountInfo")
{
var commissions = new AccountCommissions(
jObject["m"].Value <int>(), // maker
jObject["t"].Value <int>(), // taker
jObject["b"].Value <int>(), // buyer
jObject["s"].Value <int>()); // seller
var status = new AccountStatus(
jObject["T"].Value <bool>(), // can trade
jObject["W"].Value <bool>(), // can withdraw
jObject["D"].Value <bool>()); // can deposit
var balances = jObject["B"]
.Select(entry => new AccountBalance(
entry["a"].Value <string>(), // asset
entry["f"].Value <decimal>(), // free amount
entry["l"].Value <decimal>())) // locked amount
.ToList();
var eventArgs = new AccountUpdateEventArgs(eventTime, new AccountInfo(user, commissions, status, jObject["u"].Value <long>().ToDateTime(), balances));
try
{
// ReSharper disable once InconsistentlySynchronizedField
if (_accountUpdateSubscribers.TryGetValue(stream, out var subscribers))
{
foreach (var subcriber in subscribers)
{
subcriber(eventArgs);
}
}
if (callbacks != null)
{
foreach (var callback in callbacks)
{
callback(eventArgs);
}
}
AccountUpdate?.Invoke(this, eventArgs);
}
catch (OperationCanceledException) { /* ignore */ }
catch (Exception e)
{
Logger?.LogWarning(e, $"{nameof(UserDataClient)}.{nameof(HandleMessage)}: Unhandled account update event handler exception.");
}
}
else if (eventType == "executionReport")
{
var order = new Order(user);
FillOrder(order, jObject);
var executionType = ConvertOrderExecutionType(jObject["x"].Value <string>());
var rejectedReason = jObject["r"].Value <string>();
var newClientOrderId = jObject["c"].Value <string>();
if (executionType == OrderExecutionType.Trade) // trade update event.
{
var trade = new AccountTrade(
jObject["s"].Value <string>(), // symbol
jObject["t"].Value <long>(), // ID
jObject["i"].Value <long>(), // order ID
jObject["L"].Value <decimal>(), // price (price of last filled trade)
jObject["z"].Value <decimal>(), // quantity (accumulated quantity of filled trades)
jObject["n"].Value <decimal>(), // commission
jObject["N"].Value <string>(), // commission asset
jObject["T"].Value <long>()
.ToDateTime(), // time
order.Side == OrderSide.Buy, // is buyer
jObject["m"].Value <bool>(), // is buyer maker
jObject["M"].Value <bool>()); // is best price
var quantityOfLastFilledTrade = jObject["l"].Value <decimal>();
var eventArgs = new AccountTradeUpdateEventArgs(eventTime, order, rejectedReason, newClientOrderId, trade, quantityOfLastFilledTrade);
try
{
// ReSharper disable once InconsistentlySynchronizedField
if (_accountTradeUpdateSubscribers.TryGetValue(stream, out var subscribers))
{
foreach (var subcriber in subscribers)
{
subcriber(eventArgs);
}
}
if (callbacks != null)
{
foreach (var callback in callbacks)
{
callback(eventArgs);
}
}
TradeUpdate?.Invoke(this, eventArgs);
}
catch (OperationCanceledException) { /* ignore */ }
catch (Exception e)
{
Logger?.LogWarning(e, $"{nameof(UserDataClient)}.{nameof(HandleMessage)}: Unhandled trade update event handler exception.");
}
}
else // order update event.
{
var eventArgs = new OrderUpdateEventArgs(eventTime, order, executionType, rejectedReason, newClientOrderId);
try
{
// ReSharper disable once InconsistentlySynchronizedField
if (_orderUpdateSubscribers.TryGetValue(stream, out var subscribers))
{
foreach (var subcriber in subscribers)
{
subcriber(eventArgs);
}
}
if (callbacks != null)
{
foreach (var callback in callbacks)
{
callback(eventArgs);
}
}
OrderUpdate?.Invoke(this, eventArgs);
}
catch (OperationCanceledException) { /* ignore */ }
catch (Exception e)
{
Logger?.LogWarning(e, $"{nameof(UserDataClient)}.{nameof(HandleMessage)}: Unhandled order update event handler exception.");
}
}
}
else
{
Logger?.LogWarning($"{nameof(UserDataClient)}.{nameof(HandleMessage)}: Unexpected event type ({eventType}).");
}
}
catch (OperationCanceledException) { /* ignore */ }
catch (Exception e)
{
Logger?.LogError(e, $"{nameof(UserDataClient)}.{nameof(HandleMessage)}");
}
}
public bool AccountUpdate(AccountUpdate request)
{
return(_accountRepository.AccountUpdate(request));
}
/// <summary>
/// Update This updates the entity with the given properties. Only those properties which should be updated can be provided. The 'id' and 'version' are required to identify the entity.
/// </summary>
/// <exception cref="PostFinanceCheckout.Client.ApiException">Thrown when fails to make API call</exception>
/// <param name="entity">The account object with all the properties which should be updated. The id and the version are required properties.</param>
/// <returns>Account</returns>
public Account Update(AccountUpdate entity)
{
ApiResponse <Account> localVarResponse = UpdateWithHttpInfo(entity);
return(localVarResponse.Data);
}
public void SubscribeToDefaultAccountUpdates()
{
_accountUpdate = new AccountUpdate();
ClientSocket.reqAccountUpdates(true, null);
}
public bool Account_Update([FromBody] AccountUpdate request)
{
return(_accountService.AccountUpdate(request));
}
public Users Edit(int id, [FromBody] AccountUpdate obj)
{
usersAutorizator.AuthorizeEditProfila(usersService.GetRequestUserID(HttpContext.Request), id);
return(usersService.EditujProfil(id, obj));
}
public void SubscribeToAccountUpdates(string accountId)
{
_accountUpdate = new AccountUpdate();
ClientSocket.reqAccountUpdates(true, accountId);
}
public Task UpdateAsync(string id, AccountUpdate account, CancellationToken cancellationToken)
{
return(_sObjectRows.PatchAsync(nameof(Account), id, account, cancellationToken));
}
public async Task <IActionResult> PatchAsync(string id, [FromBody] AccountUpdate account, CancellationToken cancellationToken)
{
await _accountService.UpdateAsync(id, account, cancellationToken);
return(NoContent());
}
private void AccountUpdateHandler(AccountUpdate message)
{
var result = message;
Console.WriteLine(JsonConvert.SerializeObject(result, Formatting.Indented));
}
/// <summary>
/// Updates account's patchable properties
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The resource group name.
/// </param>
/// <param name='accountName'>
/// Account name.
/// </param>
/// <param name='accountUpdatePayload'>
/// Updated Account.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <Account> BeginUpdateAsync(this IAccountsOperations operations, string resourceGroupName, string accountName, AccountUpdate accountUpdatePayload, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.BeginUpdateWithHttpMessagesAsync(resourceGroupName, accountName, accountUpdatePayload, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
/// <summary>
/// Updates account's patchable properties
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The resource group name.
/// </param>
/// <param name='accountName'>
/// Account name.
/// </param>
/// <param name='accountUpdatePayload'>
/// Updated Account.
/// </param>
public static Account BeginUpdate(this IAccountsOperations operations, string resourceGroupName, string accountName, AccountUpdate accountUpdatePayload)
{
return(operations.BeginUpdateAsync(resourceGroupName, accountName, accountUpdatePayload).GetAwaiter().GetResult());
}
