public async Task Update(List <PositionPortfolio> positions)
{
var items = positions
.Where(e => e.IsOpen)
.Select(PositionPortfolioNoSql.Create)
.ToList();
if (items.Any())
{
await _dataWriter.BulkInsertOrReplaceAsync(items);
}
items = positions
.Where(e => !e.IsOpen)
.Select(PositionPortfolioNoSql.Create)
.ToList();
var list = items.Select(e => _dataWriter.DeleteAsync(e.PartitionKey, e.RowKey).AsTask()).ToList();
if (list.Any())
{
await Task.WhenAll(list);
}
}
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 override async Task <RemoveVaultConnectionResponse> RemoveVaultConnection(RemoveVaultConnectionRequest request, ServerCallContext context)
{
var tenantId = context.GetHttpContext().User.GetClaimOrDefault(Claims.TenantId);
var apiKeyId = context.GetHttpContext().User.GetClaimOrDefault(Claims.ApiKeyId);
if (string.IsNullOrEmpty(apiKeyId))
{
return(new RemoveVaultConnectionResponse()
{
Error = new ValidatorApiError()
{
Code = ValidatorApiError.Types.ErrorCodes.InternalServerError,
Message = "Incorrect Bearer Token. "
}
});
}
var validatorLinkEntity = _validatorLinkReader.Get(
ValidatorLinkEntity.GeneratePartitionKey(tenantId),
ValidatorLinkEntity.GenerateRowKey(apiKeyId));
if (validatorLinkEntity != null)
{
await _validatorLinkWriter.DeleteAsync(
ValidatorLinkEntity.GeneratePartitionKey(tenantId),
ValidatorLinkEntity.GenerateRowKey(apiKeyId));
}
return(new RemoveVaultConnectionResponse());
}
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 Logout(string traderId, Guid rootSessionId)
{
var task1 = _sessionWriter.DeleteAsync(RootSessionNoSqlEntity.GeneratePartitionKey(traderId), RootSessionNoSqlEntity.GenerateRowKey(rootSessionId)).AsTask();
var task2 = _rootSessionWriter.DeleteAsync(RootSessionNoSqlEntity.GeneratePartitionKey(traderId), RootSessionNoSqlEntity.GenerateRowKey(rootSessionId)).AsTask();
await Task.WhenAll(task1, task2);
}
public async ValueTask <bool> DeleteBitgoCoinEntityAsync(string coin)
{
if (string.IsNullOrEmpty(coin))
{
throw new Exception("Cannot update coin. Coin cannot be empty");
}
var entity = await _bitgoCoins.GetAsync(BitgoCoinEntity.GeneratePartitionKey(),
BitgoCoinEntity.GenerateRowKey(coin));
if (entity != null)
{
var assets = await _assetMap.GetAsync();
var existAssets = assets.Any(e => e.BitgoCoin == coin);
if (existAssets)
{
throw new Exception("Cannot delete coin. Asset used it as coin");
}
await _bitgoCoins.DeleteAsync(BitgoCoinEntity.GeneratePartitionKey(),
BitgoCoinEntity.GenerateRowKey(coin));
}
return(true);
}
public async Task DeleteRouteAsync(ProviderRoute newRoute)
{
var partitionKey = ProviderRouteMyNoSqlEntity.GeneratePartitionKey();
var rowKey = ProviderRouteMyNoSqlEntity.GenerateRowKey(newRoute.Id);
await _routeWriter.DeleteAsync(partitionKey, rowKey);
_logger.LogInformation("Deleted provider route {routeJson}", JsonConvert.SerializeObject(newRoute));
}
public async Task RemoveWalletAsync(string name)
{
await _noSqlDataWriter.DeleteAsync(LpWalletNoSql.GeneratePartitionKey(), LpWalletNoSql.GenerateRowKey(name));
lock (_sync)
{
_data.Remove(name);
}
_logger.LogInformation("Deleted Wallet {name}", name);
}
public async Task DeleteCountry(string countryCode)
{
var country = await GetCountry(countryCode);
await using var context = new DatabaseContext(_dbContextOptionsBuilder.Options);
context.Countries.Remove(country);
await context.SaveChangesAsync();
await _cache.DeleteAsync(KycCountryNoSqlEntity.GeneratePartitionKey(),
KycCountryNoSqlEntity.GenerateRowKey(countryCode));
}
private async Task ProcessMessageAsync(ExecutionEvent message)
{
var orders = new List <OrderEntity>();
var trades = new List <TradeEntity>();
foreach (var order in message.Orders)
{
var orderEntity = _mapper.Map <OrderEntity>(order);
orders.Add(orderEntity);
if (order.Trades == null)
{
continue;
}
foreach (var trade in order.Trades)
{
var tradeEntity = _mapper.Map <TradeEntity>(trade);
tradeEntity.AssetPairId = orderEntity.AssetPairId;
tradeEntity.OrderId = orderEntity.Id;
tradeEntity.PartitionKey = orderEntity.WalletId;
tradeEntity.WalletId = orderEntity.WalletId;
trades.Add(tradeEntity);
}
}
await _orderWriter.BulkInsertOrReplaceAsync(orders);
await _tradeWriter.BulkInsertOrReplaceAsync(trades);
Task.Run(async() =>
{
var ordersToRemove = orders
.Where(x => x.Status == OrderStatus.Matched.ToString() ||
x.Status == OrderStatus.Cancelled.ToString() ||
x.Status == OrderStatus.Rejected.ToString()).ToList();
foreach (var order in ordersToRemove)
{
await _orderWriter.DeleteAsync(order.WalletId, order.Id);
}
var walletIds = trades.Select(x => x.WalletId).Distinct().ToList();
foreach (var walletId in walletIds)
{
await _tradeWriter.CleanAndKeepMaxRecords(walletId, 0);
}
});
}
public async Task <bool> TryDeleteAsync(string partitionKey, string rowKey)
{
try
{
await _writer.DeleteAsync(partitionKey, rowKey);
return(true);
}
catch (Exception e)
{
_log.Error(e, $"Cannot execute DeleteAsync to MyNoSql with entity {typeof(TEntity).Name}", $"partitionKey: {partitionKey}; rowKey: {rowKey}");
return(false);
}
}
public override async Task <AcknowledgeResultResponse> AcknowledgeResult(AcknowledgeResultRequest request, ServerCallContext context)
{
var vaultId = context.GetVaultId();
var item = _dataReader.Get(ApprovalRequestMyNoSqlEntity.GeneratePartitionKey(request.ValidatorId),
ApprovalRequestMyNoSqlEntity.GenerateRowKey(request.TransferSigningRequestId));
if (item != null && item.VaultId == vaultId)
{
await _dataWriter.DeleteAsync(ApprovalRequestMyNoSqlEntity.GeneratePartitionKey(request.ValidatorId),
ApprovalRequestMyNoSqlEntity.GenerateRowKey(request.TransferSigningRequestId));
_logger.LogInformation("Acknowledge ApprovalResults. TransferSigningRequestId={TransferSigningRequestId}; TenantId={TenantId}; VaultId={VaultId}; ValidatorId={ValidatorId}", item.TransferSigningRequestId, item.TenantId, item.VaultId, item.ValidatorId);
}
return(new AcknowledgeResultResponse());
}
public override async Task <PingResponse> GetPing(PingRequest request, ServerCallContext context)
{
var validatorId = context.GetHttpContext().User.GetClaimOrDefault(Claims.KeyKeeperId);
var publicKey = context.GetHttpContext().User.GetClaimOrDefault(Claims.PublicKeyPem);
if (string.IsNullOrEmpty(publicKey))
{
return(new PingResponse()
{
Error = new ValidatorApiError()
{
Code = ValidatorApiError.Types.ErrorCodes.InternalServerError,
Message = "Incorrect Bearer Token."
}
});
}
var message = _pingMessageReader.Get(PingMessageMyNoSqlEntity.GeneratePartitionKey(validatorId),
PingMessageMyNoSqlEntity.GenerateRowKey());
var response = new PingResponse();
if (message == null)
{
response.MessageEnc = string.Empty;
response.SignatureMessage = string.Empty;
}
else
{
var asynccrypto = new AsymmetricEncryptionService();
var messageEnc = asynccrypto.Encrypt(Encoding.UTF8.GetBytes(message.Message), publicKey);
response.MessageEnc = Convert.ToBase64String(messageEnc);
response.SignatureMessage = "not-implemented-please-skip";
await _pingMessageWriter.DeleteAsync(message.PartitionKey, message.RowKey);
}
_logger.LogInformation("GetPing response. ValidatorId='{ValidatorId}'; HasMessage={HasMessage}", validatorId, !string.IsNullOrEmpty(response.MessageEnc));
return(response);
}
public async Task RemoveValidatorApiKeyAsync([FromBody] ValidatorRequest request)
{
var(auth, tenantId, adminId, adminEmail) = Authorize();
if (!auth)
{
return;
}
var entity = _validationReader.Get(ValidatorLinkEntity.GeneratePartitionKey(tenantId),
ValidatorLinkEntity.GenerateRowKey(request.ApiKeyId));
if (entity == null)
{
return;
}
await _validationWriter.DeleteAsync(entity.PartitionKey, entity.RowKey);
_logger.LogInformation("Removed validator Api Key: {ApiKeyId}; AdminId: {AdminId}; Name: {Name}; Device: {Device}; TenantId: {TenantId}", request.ApiKeyId, adminId, entity.Name, entity.DeviceInfo, tenantId);
}
public async Task KillRootSessionAsync(KillRootSessionRequest request)
{
using var activity = MyTelemetry.StartActivity("Kill Root Session");
if (string.IsNullOrEmpty(request.SessionRootId) || string.IsNullOrEmpty(request.ClientId))
{
_logger.LogWarning("Cannot kill session, RootSessionId is empty or ClientId is empty");
activity.SetStatus(Status.Error);
return;
}
await _writer.DeleteAsync(SpotSessionNoSql.GeneratePartitionKey(request.ClientId), SpotSessionNoSql.GenerateRowKey(request.SessionRootId));
request.ClientId.AddToActivityAsTag("clientId");
request.SessionRootId.AddToActivityAsTag("sessionRootId");
await _sessionAuditService.KillSessionAudit(request.SessionRootId, request.SessionId, request.ClientId, request.Reason, request.UserAgent, request.Ip);
_logger.LogInformation("Session is killed. ClientId: {clientId}, RootSessionId: {rootIdText}", request.ClientId, request.SessionRootId);
}
public async Task <OperationResponse> DeleteWithdrawalProfile(DeleteProfileRequest request)
{
try
{
var groups = await _profileWriter.GetAsync(FeeProfilesNoSqlEntity.GeneratePartitionKey(),
FeeProfilesNoSqlEntity.GenerateRowKey());
var withdrawalList = groups?.Profiles ?? new List <string>();
var depositList = groups?.DepositProfiles ?? new List <string>()
{
FeeProfileConsts.DefaultProfile
};
var list = withdrawalList.Distinct().ToList();
list.Remove(request.ProfileId);
await _profileWriter.InsertOrReplaceAsync(FeeProfilesNoSqlEntity.Create(list, depositList));
var assets =
(await _assetWriter.GetAsync(
AssetFeesNoSqlEntity.GeneratePartitionKey(request.BrokerId, request.ProfileId))).ToList();
foreach (var asset in assets)
{
await _assetWriter.DeleteAsync(asset.PartitionKey, asset.RowKey);
}
return(new OperationResponse()
{
IsSuccess = true
});
}
catch (Exception e)
{
return(new OperationResponse()
{
IsSuccess = false,
ErrorText = e.Message
});
}
}
public async ValueTask <bool> DeleteBitgoAssetMapEntityAsync(string brokerId, string assetSymbol)
{
if (string.IsNullOrEmpty(brokerId))
{
throw new Exception("Cannot delete asset map. BrokerId cannot be empty");
}
if (string.IsNullOrEmpty(assetSymbol))
{
throw new Exception("Cannot delete asset map. AssetSymbol cannot be empty");
}
var entity = await _assetMap.GetAsync(BitgoAssetMapEntity.GeneratePartitionKey(brokerId),
BitgoAssetMapEntity.GenerateRowKey(assetSymbol));
if (entity != null)
{
await _assetMap.DeleteAsync(BitgoAssetMapEntity.GeneratePartitionKey(brokerId),
BitgoAssetMapEntity.GenerateRowKey(assetSymbol));
}
return(true);
}
public async Task LogoutAsync(SessionEntity session)
{
await _sessionsWriter.DeleteAsync(session.PartitionKey, session.RowKey);
await _clientSessionsClient.DeleteSessionIfExistsAsync(session.Token);
}
private async Task <GetDepositAddressResponse> GetBitgoDepositAddressAsync(GetDepositAddressRequest request)
{
try
{
var(bitgoCoin, bitgoWalletId) =
_assetMapper.AssetToBitgoCoinAndWallet(request.BrokerId, request.AssetSymbol);
if (string.IsNullOrEmpty(bitgoWalletId) || string.IsNullOrEmpty(bitgoCoin))
{
_logger.LogError(
"Cannot process GetDepositAddress. Asset do not mapped to bitgo. Request: {jsonText}",
JsonConvert.SerializeObject(request));
return(new GetDepositAddressResponse
{
Error = GetDepositAddressResponse.ErrorCode.AssetDoNotSupported
});
}
Error error = null;
var label = _walletMapper.WalletToBitgoLabel(new JetWalletIdentity
{
BrokerId = request.BrokerId,
ClientId = request.ClientId,
WalletId = request.WalletId
});
await using var ctx = DatabaseContext.Create(_dbContextOptionsBuilder);
var addressEntity = await ctx.Addresses.Where(t =>
t.BrokerId == request.BrokerId && t.ClientId == request.ClientId &&
t.WalletId == request.WalletId && t.Blockchain == request.Blockchain &&
t.AssetSymbol == request.AssetSymbol).FirstOrDefaultAsync();
var address = addressEntity?.Address;
if (string.IsNullOrEmpty(address))
{
(address, error) =
await _depositAddressGeneratorService.GetAddressAsync(bitgoCoin, bitgoWalletId, label);
}
if (string.IsNullOrEmpty(address))
{
var preGeneratedAddresses = (await _generatedAddressDataWriter.GetAsync(
GeneratedDepositAddressEntity.GeneratePartitionKey(request.BrokerId, bitgoCoin,
bitgoWalletId, request.Blockchain)))
.ToList();
if (preGeneratedAddresses.Count > 0)
{
var preGeneratedAddress = preGeneratedAddresses.First();
(address, error) = await _depositAddressGeneratorService.UpdateAddressLabelAsync(bitgoCoin,
bitgoWalletId,
preGeneratedAddress.Address.BitGoAddressId, label);
if (error == null)
{
await _generatedAddressDataWriter.DeleteAsync(preGeneratedAddress.PartitionKey,
preGeneratedAddress.RowKey);
}
}
else
{
(address, error) =
await _depositAddressGeneratorService.GenerateAddressAsync(bitgoCoin, bitgoWalletId, label);
}
}
if (string.IsNullOrEmpty(address) || error != null)
{
_logger.LogError(
"Cannot process GetDepositAddress. Unable to generate address. Request: {jsonText}. Error: {error}",
JsonConvert.SerializeObject(request), error);
return(new GetDepositAddressResponse
{
Error = GetDepositAddressResponse.ErrorCode.AddressNotGenerated
});
}
if (addressEntity == null)
{
await ctx.InsertAsync(new DepositAddressSqlEntity
{
BrokerId = request.BrokerId,
ClientId = request.ClientId,
WalletId = request.WalletId,
Integration = "BitGo",
AssetSymbol = request.AssetSymbol,
Blockchain = request.Blockchain,
Address = address,
CreatedDate = DateTime.Now
});
}
await _addressDataWriter.InsertOrReplaceAsync(DepositAddressEntity.Create(request.WalletId,
request.AssetSymbol, request.Blockchain, address));
await _addressDataWriter.CleanAndKeepMaxPartitions(Program.Settings.MaxClientInCache);
_logger.LogInformation("Handle GetDepositAddress, request: {jsonText}, address: {address}",
JsonConvert.SerializeObject(request), address);
return(new GetDepositAddressResponse
{
Address = address,
Error = GetDepositAddressResponse.ErrorCode.Ok
});
}
catch (Exception ex)
{
_logger.LogError(ex, "Exception on GetDepositAddress with request: {jsonText}",
JsonConvert.SerializeObject(request));
throw;
}
}
public async Task DeleteAsync(string id)
{
await _myNoSqlServerDataWriter.DeleteAsync(NotificationChannelNoSql.GeneratePartitionKey(),
NotificationChannelNoSql.GenerateRowKey(id));
}
public async Task CloseSession(SessionEntity session, string reason)
{
await _sessionsWriter.DeleteAsync(session.PartitionKey, session.RowKey);
}