private async Task <GetBalancesResponse> RefreshBalancesAsync()
{
using var activity = MyTelemetry.StartActivity("Load balance info");
var data = await _restApi.GetBalancesAsync();
if (data.Success)
{
_response = new GetBalancesResponse()
{
Balances = data.Result.Select(e => new ExchangeBalance()
{
Symbol = e.Coin, Balance = e.Total, Free = e.Free
}).ToList()
};
_lastUpdate = DateTime.UtcNow;
}
else
{
throw new Exception($"Cannot get balance, error: {data.Error}");
}
_response.AddToActivityAsJsonTag("balance");
_logger.LogDebug("Balance refreshed");
return(_response);
}
public async Task <GetWalletInfoByIdResponse> GetWalletInfoByIdAsync(GetWalletInfoByIdRequest request)
{
using var activity = MyTelemetry.StartActivity("GetWalletInfoByIdAsync");
request.AddToActivityAsJsonTag("request");
await using var ctx = new DatabaseContext(_dbContextOptionsBuilder.Options);
var walletEntity = ctx.ClientWallet.FirstOrDefault(e => e.WalletId == request.WalletId);
if (walletEntity == null)
{
return(new GetWalletInfoByIdResponse()
{
Success = false,
ErrorMessage = "Wallet not found"
});
}
return(new GetWalletInfoByIdResponse()
{
Success = true,
WalletInfo = new ClientWallet()
{
BaseAsset = walletEntity.BaseAsset,
CreatedAt = walletEntity.CreatedAt,
EnableUseTestNet = walletEntity.EnableUseTestNet,
IsDefault = walletEntity.IsDefault,
IsInternal = walletEntity.IsInternal,
Name = walletEntity.Name,
WalletId = walletEntity.WalletId,
EnableEarnProgram = walletEntity.EnableEarnProgram
}
});
}
private async ValueTask Reader(IConfirmationContext confirmationContext, IReadOnlyList <IMyServiceBusMessage> messages)
{
using var activity = MyTelemetry.StartActivity($"Handle Events {typeof(T).Name}");
//var size = 0;
//size = messages.Sum(e => e.Data.Length);
//Console.WriteLine($"Receive {messages.Count} messages. {(decimal)size/1024/1024} mb");
//Console.WriteLine($"no: {messages.First().Id} ({messages.First().AttemptNo})");
//var sw = new Stopwatch();
//sw.Start();
var packets = messages.Select(e => _deserializer(e.Data)).ToList();
//sw.Stop();
//Console.WriteLine($"Parse for {sw.Elapsed}");
packets.Count.AddToActivityAsTag("count-events");
foreach (var itm in packets)
{
foreach (var subscribers in _list)
{
await subscribers(itm);
}
}
}
public async Task RemoveBitGoWallet(RemoveBitGoWalletRequest request)
{
using var action = MyTelemetry.StartActivity("Remove BitGo wallet");
request.AddToActivityAsJsonTag("request");
try
{
_logger.LogInformation("Remove BitGo wallet: {jsonText}",
JsonConvert.SerializeObject(request));
var entity = await _writer.DeleteAsync(BitGoWalletNoSqlEntity.GeneratePartitionKey(request.BrokerId),
BitGoWalletNoSqlEntity.GenerateRowKey(request.WalletId));
if (entity != null)
{
_logger.LogInformation("Removed BitGo wallet: {jsonText}",
JsonConvert.SerializeObject(entity, new ApiKeyHiddenJsonConverter(typeof(BitGoWallet))));
}
else
{
_logger.LogInformation("Unable to remove BitGo wallet, do not exist: {jsonText}",
JsonConvert.SerializeObject(request));
}
}
catch (Exception ex)
{
_logger.LogError(ex, "Cannot remove BitGo wallet: {requestJson}",
JsonConvert.SerializeObject(request));
ex.FailActivity();
throw;
}
}
public async Task RemoveSpotInstrumentFeesSettings(RemoveSpotInstrumentFeesRequest request)
{
using var action = MyTelemetry.StartActivity("Remove Spot Instrument Fees Settings");
request.AddToActivityAsJsonTag("request");
try
{
_logger.LogInformation("Remove Spot Instrument Fees Setting: {jsonText}",
JsonConvert.SerializeObject(request));
var entity = await _writer.DeleteAsync(SpotInstrumentFeesNoSqlEntity.GeneratePartitionKey(request.BrokerId),
SpotInstrumentFeesNoSqlEntity.GenerateRowKey(request.SpotInstrumentId));
if (entity != null)
{
_logger.LogInformation("Removed Spot Instrument Fees Settings: {jsonText}",
JsonConvert.SerializeObject(entity));
}
else
{
_logger.LogInformation("Unable to remove Spot Instrument Fees Setting, do not exist: {jsonText}",
JsonConvert.SerializeObject(request));
}
}
catch (Exception ex)
{
_logger.LogError(ex, "Cannot remove ExternalMarketSettings: {requestJson}",
JsonConvert.SerializeObject(request));
ex.FailActivity();
throw;
}
}
public async Task <SearchWalletsResponse> SearchClientsAsync(SearchWalletsRequest request)
{
using var activity = MyTelemetry.StartActivity($"Search client");
request.AddToActivityAsJsonTag("request");
await using var ctx = new DatabaseContext(_dbContextOptionsBuilder.Options);
var data = await ctx.ClientWallet
.Where(e => e.ClientId.Contains(request.SearchText) || e.WalletId.Contains(request.SearchText))
.GroupBy(e => new { e.BrokerId, e.ClientId })
.Select(e => new { e.Key.BrokerId, e.Key.ClientId, Count = e.Count() })
.Take(request.Take)
.ToListAsync();
data.Count.AddToActivityAsTag("result-count");
return(new SearchWalletsResponse()
{
Clients = data.Select(e => new SearchWallet()
{
BrokerId = e.BrokerId,
ClientId = e.ClientId,
Count = e.Count
}).ToList()
});
}
public override async Task OrderBookSnapshots(Empty request, IServerStreamWriter <OrderBookSnapshot> responseStream, ServerCallContext context)
{
using var activity = MyTelemetry.StartActivity("OrderBookSnapshots");
using var resp = _orderBooksServiceClient.OrderBookSnapshots(new Empty(), cancellationToken: context.CancellationToken);
await resp.ResponseStream.ForEachAsync(responseStream.WriteAsync);
}
public async Task UpdateSpotInstrumentFeesSettings(SpotInstrumentFees settings)
{
using var action = MyTelemetry.StartActivity("Update Spot Instrument Fees Settings");
settings.AddToActivityAsJsonTag("settings");
try
{
_logger.LogInformation("Update Spot Instrument Fees Setting: {jsonText}",
JsonConvert.SerializeObject(settings));
ValidateSettings(settings);
var entity = SpotInstrumentFeesNoSqlEntity.Create(settings);
var existingItem = await _writer.GetAsync(entity.PartitionKey, entity.RowKey);
if (existingItem == null)
{
throw new Exception("Cannot update Spot Instrument Fees Settings. Do not exist");
}
await _writer.InsertOrReplaceAsync(entity);
_logger.LogInformation("Updated Spot Instrument Fees Setting: {jsonText}",
JsonConvert.SerializeObject(settings));
}
catch (Exception ex)
{
_logger.LogError(ex, "Cannot update ExternalMarketSettings: {requestJson}",
JsonConvert.SerializeObject(settings));
ex.FailActivity();
throw;
}
}
private async Task UpdateWithTransactionDetails(SignalCircleTransfer transfer)
{
using var activity = MyTelemetry.StartActivity("Handle event SignalCircleTransfer");
transfer.AddToActivityAsTag("circle-transfer");
try
{
await using var context = new DatabaseContext(_dbContextOptionsBuilder.Options);
var withdrawal = await context.Withdrawals
.Where(e => e.Integration == "Circle" && e.ExternalSystemId == transfer.PaymentInfo.Id)
.FirstOrDefaultAsync();
if (withdrawal == null)
{
_logger.LogError("Unable to find withdrawal with external system id {withdrawalId}",
transfer.PaymentInfo.Id);
return;
}
withdrawal.Txid = transfer.PaymentInfo.TransactionHash;
await context.UpdateAsync(withdrawal);
}
catch (Exception)
{
_logger.LogError("Unable to update withdrawal details {withdrawalId}",
transfer.PaymentInfo.Id);
}
}
private async ValueTask HandleKycStatusUpdate(IReadOnlyList <PersonalDataUpdateMessage> kycStatusUpdates)
{
foreach (var kycStatusUpdate in kycStatusUpdates)
{
using var _ = MyTelemetry.StartActivity("Handle event KycStatusUpdate")
?.AddTag("clientId", kycStatusUpdate.TraderId);
var personalDataResponse =
await _personalDataServiceGrpc.GetByIdAsync(new GetByIdRequest()
{
Id = kycStatusUpdate.TraderId
});
if (personalDataResponse.PersonalData == null)
{
return;
}
if (personalDataResponse.PersonalData.Confirm != null &&
personalDataResponse.PersonalData.ConfirmPhone != null)
{
await _clientProfileService.SetKYCPassed(new SetKYCPassedRequest()
{
ClientId = kycStatusUpdate.TraderId
});
}
_logger.LogDebug($"[ClientID:{kycStatusUpdate.TraderId}] setting KYC status as Passed");
}
}
public async Task SetEarnProgramByWalletAsync(SetEarnProgramByWalletRequest request)
{
using var activity = MyTelemetry.StartActivity("SetEarnProgramByWalletAsync");
request.AddToActivityAsJsonTag("request");
_logger.LogWarning("Change EnableEarnProgram. Wallet: {walletId}, EnableEarnProgram: {flag}", request.WalletId, request.EnableEarnProgram);
await using var ctx = new DatabaseContext(_dbContextOptionsBuilder.Options);
var walletEntity = ctx.ClientWallet.FirstOrDefault(e => e.WalletId == request.WalletId);
if (walletEntity != null)
{
var oldWallet = (ClientWallet)walletEntity.Clone();
walletEntity.EnableEarnProgram = request.EnableEarnProgram;
await ctx.SaveChangesAsync();
await UpdateCache(
walletEntity.ClientId,
walletEntity.BrokerId,
new List <ClientWalletEntity> {
walletEntity
});
await _publisher.PublishAsync(new ClientWalletUpdateMessage()
{
OldWallet = ClientWallet.Create(oldWallet),
NewWallet = ClientWallet.Create(walletEntity)
});
}
}
public async Task <GetAllClientsResponse> GetAllClientsAsync()
{
using var activity = MyTelemetry.StartActivity($"GetAllClients");
await using var ctx = new DatabaseContext(_dbContextOptionsBuilder.Options);
var dataRaw = await ctx.ClientWallet.ToListAsync();
var data = dataRaw
.GroupBy(e => new { e.BrokerId, e.ClientId })
.Select(e => new ClientGrpc()
{
BrokerId = e.Key.BrokerId,
ClientId = e.Key.ClientId,
Wallets = e.Select(x => x.WalletId).ToList()
})
.ToList();
data.Count.AddToActivityAsTag("result-count");
return(new GetAllClientsResponse()
{
Clients = data
});
}
public async Task UpdateBitGoWallet(BitGoWallet wallet)
{
using var action = MyTelemetry.StartActivity("Update BitGo wallet");
wallet.ApiKey = _encryptionService.Encrypt(wallet.ApiKey);
try
{
_logger.LogInformation("Update BitGoWallet: {jsonText}",
JsonConvert.SerializeObject(wallet, new ApiKeyHiddenJsonConverter(typeof(BitGoWallet))));
wallet.UpdatedDate = DateTime.Now;
ValidateWallet(wallet);
var entity = BitGoWalletNoSqlEntity.Create(wallet);
var existingItem = await _writer.GetAsync(entity.PartitionKey, entity.RowKey);
if (existingItem == null)
{
throw new Exception("Cannot update BitGo wallet. Do not exist");
}
await _writer.InsertOrReplaceAsync(entity);
_logger.LogInformation("Updated BitGo wallet: {jsonText}",
JsonConvert.SerializeObject(wallet, new ApiKeyHiddenJsonConverter(typeof(BitGoWallet))));
}
catch (Exception ex)
{
_logger.LogError(ex, "Cannot update BitGo wallet: {requestJson}",
JsonConvert.SerializeObject(wallet, new ApiKeyHiddenJsonConverter(typeof(BitGoWallet))));
ex.FailActivity();
throw;
}
}
public override Task <CashInOutOperationResponse> CashInOut(CashInOutOperation request,
ServerCallContext context)
{
var isWithdrawal = double.Parse(request.Volume) < 0;
using var activity = MyTelemetry.StartActivity(isWithdrawal ? "Withdrawal" : "Deposit");
activity?.AddTag("operationId", request.Id)
.AddTag("brokerId", request.BrokerId)
.AddTag("accountId", request.AccountId)
.AddTag("walletId", request.WalletId)
.AddTag("assetId", request.AssetId)
.AddTag("volume", request.Volume);
if (isWithdrawal && request.Fees.Count == 0)
{
var fees = _assetFeesClient.GetAssetFees(request.BrokerId, request.AssetId,
OperationType.Withdrawal);
if (fees != null)
{
request.Fees.Add(FeesConverter.ConvertAssetFee(fees));
}
}
return(_cashServiceClient.CashInOutAsync(request, cancellationToken: context.CancellationToken)
.ResponseAsync);
}
public async Task <ClientWalletList> GetWalletsByClient(JetClientIdentity clientId)
{
_logger.LogInformation("Request wallets for Broker/Brand/Client: {brokerId}/{clientId}",
clientId.BrokerId, clientId.ClientId);
clientId.BrokerId.AddToActivityAsTag("brokerId");
clientId.ClientId.AddToActivityAsTag("clientId");
_logger.LogInformation("Request to get wallets. clientId: {clientText}", JsonSerializer.Serialize(clientId));
using var activity = MyTelemetry.StartActivity($"Use DB context {DatabaseContext.Schema}")?.AddTag("db-schema", DatabaseContext.Schema);
await using var ctx = new DatabaseContext(_dbContextOptionsBuilder.Options);
var list = await ctx.ClientWallet.Where(e => e.BrokerId == clientId.BrokerId && e.ClientId == clientId.ClientId)
.ToListAsync();
if (!list.Any())
{
using var _ = MyTelemetry.StartActivity($"Create a new wallet");
var wallet = new ClientWallet()
{
IsDefault = true,
IsInternal = false,
EnableEarnProgram = true,
Name = "spot",
WalletId = GenerateDefaultWalletId(clientId.ClientId),
CreatedAt = DateTime.UtcNow,
BaseAsset = Program.Settings.BaseAssetSymbol,
EnableUseTestNet = Program.Settings.EnableUseTestNetByDefault
};
wallet.WalletId.AddToActivityAsTag("walletId");
var entity = new ClientWalletEntity(clientId.BrokerId, clientId.ClientId, wallet);
await ctx.UpsetAsync(new [] { entity });
list.Add(entity);
_logger.LogInformation("Created default wallet. Wallet: {walletJson}", JsonSerializer.Serialize(entity));
}
foreach (var clientWalletEntity in list.Where(e => string.IsNullOrWhiteSpace(e.BaseAsset)))
{
clientWalletEntity.BaseAsset = Program.Settings.BaseAssetSymbol;
}
await UpdateCache(clientId.ClientId, clientId.BrokerId, list);
return(new ClientWalletList()
{
Wallets = list.Select(e => new ClientWallet()
{
IsDefault = e.IsDefault, Name = e.Name,
WalletId = e.WalletId, CreatedAt = e.CreatedAt, BaseAsset = e.BaseAsset,
EnableUseTestNet = e.EnableUseTestNet, IsInternal = e.IsInternal, EnableEarnProgram = e.EnableEarnProgram
}).ToList()
});
}
public override Task <BalancesGetAllResponse> GetAll(BalancesGetAllRequest request, ServerCallContext context)
{
using var activity = MyTelemetry.StartActivity("Balances.GetAll");
activity?.AddTag("brokerId", request.BrokerId)
.AddTag("walletId", request.WalletId);
return(_balancesServiceClient.GetAllAsync(request).ResponseAsync);
}
public async Task <RetryWithdrawalResponse> RetryWithdrawal(RetryWithdrawalRequest request)
{
using var activity = MyTelemetry.StartActivity("Handle withdrawal manual retry")
.AddTag("WithdrawalId", request.WithdrawalId);
_logger.LogInformation("Handle withdrawal manual retry: {withdrawalId}", request.WithdrawalId);
try
{
await using var context = new DatabaseContext(_dbContextOptionsBuilder.Options);
var withdrawal = await context.Withdrawals.FindAsync(request.WithdrawalId);
if (withdrawal == null)
{
_logger.LogInformation("Unable to find withdrawal with id {withdrawalId}", request.WithdrawalId);
return(new RetryWithdrawalResponse
{
Success = false,
ErrorMessage = "Unable to find withdrawal",
WithdrawalId = request.WithdrawalId
});
}
if (withdrawal.Status == WithdrawalStatus.Success)
{
_logger.LogInformation("Withdrawal {withdrawalId} already processed", request.WithdrawalId);
return(new RetryWithdrawalResponse
{
Success = true,
WithdrawalId = request.WithdrawalId
});
}
await _cryptoWithdrawalService.RetryWithdrawalAsync(withdrawal);
await context.UpdateAsync(withdrawal);
_logger.LogInformation("Handled withdrawal manual retry: {withdrawalId}", request.WithdrawalId);
return(new RetryWithdrawalResponse
{
Success = true,
WithdrawalId = request.WithdrawalId
});
}
catch (Exception ex)
{
_logger.LogError(ex, "Cannot Handle withdrawals");
ex.FailActivity();
return(new RetryWithdrawalResponse
{
Success = false,
ErrorMessage = $"Internal error {ex.Message}",
WithdrawalId = request.WithdrawalId
});
}
}
public void Test_MyTelemetry()
{
var mtm = new MyTelemetry(new TelemetryClient(TelemetryConfiguration.CreateDefault()));
var met = mtm.GetMetric("foo");
Assert.IsInstanceOf <MyMetric>(met);
var mymet = (MyMetric)met;
Assert.IsNotNull(mymet.Metric);
}
public async Task <SetBaseAssetResponse> SetBaseAssetAsync(SetBaseAssetRequest request)
{
using var activity = MyTelemetry.StartActivity($"Set base asset request");
request.AddToActivityAsJsonTag("request");
request.ClientId.ClientId.AddToActivityAsTag("clientId");
request.ClientId.BrokerId.AddToActivityAsTag("brokerId");
request.WalletId.AddToActivityAsTag("WalletId");
if (string.IsNullOrEmpty(request.ClientId?.ClientId) ||
string.IsNullOrEmpty(request.ClientId?.BrokerId) ||
string.IsNullOrEmpty(request.WalletId) ||
string.IsNullOrWhiteSpace(request.BaseAsset))
{
var message = "Cannot set base asset. BadRequest.";
_logger.LogError(message);
return(new SetBaseAssetResponse()
{
Success = false,
ErrorMessage = message
});
}
await using var ctx = new DatabaseContext(_dbContextOptionsBuilder.Options);
var walletEntity = ctx.ClientWallet.FirstOrDefault(e => e.WalletId == request.WalletId);
if (walletEntity == null)
{
var message = $"Wallet not found. WalletId: {request.WalletId}";
_logger.LogError(message);
return(new SetBaseAssetResponse()
{
Success = false,
ErrorMessage = message
});
}
var oldWallet = (ClientWallet)walletEntity.Clone();
walletEntity.BaseAsset = request.BaseAsset;
await ctx.SaveChangesAsync();
await UpdateCache(request.ClientId.ClientId, request.ClientId.BrokerId, new List <ClientWalletEntity> {
walletEntity
});
await _publisher.PublishAsync(new ClientWalletUpdateMessage()
{
OldWallet = ClientWallet.Create(oldWallet),
NewWallet = ClientWallet.Create(walletEntity)
});
return(new SetBaseAssetResponse()
{
Success = true
});
}
public async Task <WalletBalanceUpdateList> GetBalanceUpdatesAsync(GetBalanceUpdateRequest request)
{
var take = request.Take ?? DefaultTakeValue;
try
{
using var activity = MyTelemetry.StartActivity($"Use DB context {DatabaseContext.Schema}")?.AddTag("db-schema", DatabaseContext.Schema);
await using var ctx = DatabaseContext.Create(_dbContextOptionsBuilder);
List <BalanceHistoryEntity> balanceHistory;
IQueryable <BalanceHistoryEntity> query = ctx.BalanceHistory
.Where(elem => elem.WalletId == request.WalletId);
if (request.LastSequenceId != null)
{
query = query.Where(e => e.SequenceId < request.LastSequenceId);
}
if (!string.IsNullOrEmpty(request.Symbol))
{
query = query.Where(e => e.Symbol == request.Symbol);
}
if (request.OnlyBalanceChanged)
{
query = query.Where(e => e.IsBalanceChanged);
}
balanceHistory = await query
.OrderByDescending(elem => elem.SequenceId)
.ThenByDescending(t => t.Timestamp)
.Take(take)
.ToListAsync();
var resp = new WalletBalanceUpdateList {
BalanceUpdates = new List <WalletBalanceUpdate>()
};
resp.BalanceUpdates.AddRange(balanceHistory.Select(e => new WalletBalanceUpdate(e)));
return(resp);
}
catch (Exception e)
{
_logger.LogError(e, "Cannot get BalanceUpdate for walletId: {walletId}, take: {takeValue}, LastSequenceId: {LastSequenceId}",
request.WalletId, take, request.LastSequenceId);
e.WriteToActivity();
request.AddToActivityAsJsonTag("request");
throw;
}
}
public static DatabaseContext Create(DbContextOptionsBuilder <DatabaseContext> options)
{
var activity = MyTelemetry.StartActivity($"Database context {Schema}")?.AddTag("db-schema", Schema);
var ctx = new DatabaseContext(options.Options)
{
_activity = activity
};
return(ctx);
}
private async ValueTask HandleSignal(SignalCircleTransfer signal)
{
using var activity = MyTelemetry.StartActivity("Handle Event SignalBitGoTransfer");
try
{
await _service.HandledDepositAsync(signal);
}
catch (Exception ex)
{
ex.FailActivity();
throw;
}
}
private async ValueTask HandleSignal(FireblocksDepositSignal signal)
{
using var activity = MyTelemetry.StartActivity("Handle Event FireblocksDepositSignal");
try
{
await _service.HandledDepositAsync(signal);
}
catch (Exception ex)
{
ex.FailActivity();
throw;
}
}
public override Task <LimitOrderCancelResponse> CancelLimitOrder(LimitOrderCancel request,
ServerCallContext context)
{
using var activity = MyTelemetry.StartActivity("CancelLimitOrder");
activity?.AddTag("operationId", request.Id)
.AddTag("brokerId", request.BrokerId)
.AddTag("accountId", request.AccountId)
.AddTag("walletId", request.WalletId)
.AddTag("orderIds", request.LimitOrderId);
return(_tradingServiceClient.CancelLimitOrderAsync(request, cancellationToken: context.CancellationToken)
.ResponseAsync);
}
private async ValueTask HandleTrades(IReadOnlyList <WalletTradeMessage> trades)
{
var wallets = _walletManager.GetAll().Select(e => e.WalletId).ToList();
var list = trades.Where(e => wallets.Contains(e.WalletId)).ToList();
if (list.Any())
{
using var _ = MyTelemetry.StartActivity("Handle event WalletTradeMessage")
?.AddTag("event-count", list.Count)?.AddTag("event-name", "WalletTradeMessage");
await _manager.RegisterLocalTradesAsync(list);
lock (_sync) _needToHedge = true;
}
}
public override Task <CashTransferOperationResponse> CashTransfer(CashTransferOperation request,
ServerCallContext context)
{
using var activity = MyTelemetry.StartActivity("CashTransfer");
activity?.AddTag("operationId", request.Id)
.AddTag("brokerId", request.BrokerId)
.AddTag("accountId", request.AccountId)
.AddTag("fromWalletId", request.FromWalletId)
.AddTag("toWalletId", request.ToWalletId)
.AddTag("assetId", request.AssetId)
.AddTag("volume", request.Volume);
return(_cashServiceClient.CashTransferAsync(request, cancellationToken: context.CancellationToken)
.ResponseAsync);
}
public override Task <ReservedCashInOutOperationResponse> ReservedCashInOut(ReservedCashInOutOperation request,
ServerCallContext context)
{
using var activity = MyTelemetry.StartActivity("ReservedCashTransfer");
activity?.AddTag("operationId", request.Id)
.AddTag("brokerId", request.BrokerId)
.AddTag("accountId", request.AccountId)
.AddTag("walletId", request.WalletId)
.AddTag("assetId", request.AssetId)
.AddTag("reservedVolume", request.ReservedVolume)
.AddTag("reservedSwapVolume", request.ReservedForSwapVolume);
return(_cashServiceClient.ReservedCashInOutAsync(request, cancellationToken: context.CancellationToken)
.ResponseAsync);
}
public override Task <MultiLimitOrderResponse> MultiLimitOrder(MultiLimitOrder request,
ServerCallContext context)
{
using var activity = MyTelemetry.StartActivity("MultiLimitOrder");
activity?.AddTag("operationId", request.Id)
.AddTag("brokerId", request.BrokerId)
.AddTag("accountId", request.AccountId)
.AddTag("walletId", request.WalletId)
.AddTag("assetPairId", request.AssetPairId)
.AddTag("ordersCount", request.Orders.Count);
AddMultiLimitOrderFees(request);
return(_tradingServiceClient.MultiLimitOrderAsync(request, cancellationToken: context.CancellationToken)
.ResponseAsync);
}
public async Task <ManualChangeAuditResponse> GetManualChangeAudit(ManualChangeAuditRequest request)
{
try
{
using var activity = MyTelemetry.StartActivity($"Use DB context {DatabaseContext.Schema}")
?.AddTag("db-schema", DatabaseContext.Schema);
await using var ctx = DatabaseContext.Create(_dbContextOptionsBuilder);
var query = string.IsNullOrWhiteSpace(request.SearchText)
? ctx.ManualChangeAudit
: ctx.ManualChangeAudit.Where(e =>
e.Officer.Contains(request.SearchText) ||
e.ClientId.Contains(request.SearchText) ||
e.TransactionId.Contains(request.SearchText) ||
e.WalletId.Contains(request.SearchText) ||
e.Comment.Contains(request.SearchText));
query = query.OrderByDescending(t => t.TimeStamp);
if (request.Skip != 0)
{
query = query.Skip(request.Skip);
}
if (request.Take != 0)
{
query = query.Take(request.Take);
}
var list = await query.ToListAsync();
return(new ManualChangeAuditResponse {
Operations = list
});
}
catch (Exception e)
{
_logger.LogError(e,
"Cannot get ManualChangeAudit for searchText: {searchText}, skip: {skip}, take: {take}",
request.SearchText, request.Skip, request.Take);
e.WriteToActivity();
request.AddToActivityAsJsonTag("request");
throw;
}
}
public async Task SetEarnProgramByWalletAsync(SetEarnProgramByWalletRequest request)
{
using var activity = MyTelemetry.StartActivity("SetEarnProgramByWalletAsync");
request.AddToActivityAsJsonTag("request");
_logger.LogWarning("Change EnableEarnProgram. Wallet: {walletId}, EnableEarnProgram: {flag}", request.WalletId, request.EnableEarnProgram);
await using var ctx = new DatabaseContext(_dbContextOptionsBuilder.Options);
var walletEntity = ctx.ClientWallet.FirstOrDefault(e => e.WalletId == request.WalletId);
if (walletEntity != null)
{
walletEntity.EnableEarnProgram = request.EnableEarnProgram;
await ctx.SaveChangesAsync();
}
}
