public async Task RegisterNewSessionAsync(AuthorizationToken token, RefreshToken refreshToken, string userAgent, string ip, string description, PlatformTypes platformType, LoginApplication application)
{
if (!token.RootSessionId.HasValue)
{
throw new Exception("Cannot RegisterNewSession without RootSessionId");
}
var pkBase64 = token.PublicKey != null?Convert.ToBase64String(token.PublicKey) : "";
var session = RootSessionNoSqlEntity.Generate(token.RootSessionId.Value, token.TraderId(), token.BrandId, userAgent, ip, pkBase64,
token.Passed2FA, token.EmailVerified, description, platformType, application);
session.Expires = refreshToken.Expires;
var task1 = _sessionWriter.InsertOrReplaceAsync(session).AsTask();
var shortSession = ShortRootSessionNoSqlEntity.Create(session);
shortSession.Expires = refreshToken.Expires;
var task2 = _rootSessionWriter.InsertOrReplaceAsync(shortSession).AsTask();
var task3 = _rootSessionWriter.GetCountAsync(
ShortRootSessionNoSqlEntity.GeneratePartitionKey(token.TraderId())).AsTask();
await Task.WhenAll(task1, task2, task3);
if (task3.Result > _maxSessionsCount)
{
var sessions = await _sessionWriter.GetAsync(
ShortRootSessionNoSqlEntity.GeneratePartitionKey(token.TraderId()));
var oldestSession = sessions.OrderBy(s => s.CreateTime).First();
await Logout(token.TraderId(), oldestSession.RootSessionId);
}
}
public async Task CreateDefaultTemplatesAsync()
{
var templateEntities = (await _templateWriter.GetAsync())?.ToArray();
var templateIds = Enum.GetValues(typeof(TemplateEnum)).Cast <TemplateEnum>();
foreach (var templateId in templateIds)
{
var template = templateEntities?.FirstOrDefault(e => e.Template.Id == templateId)?.Template;
if (template == null)
{
template = new SmsTemplate
{
Id = templateId,
DefaultLang = _defaultLang,
DefaultBrand = _defaultBrand,
BrandLangBodies = GetTemplateLangBodies(templateId),
Params = GetTemplateBodyParams(templateId)
};
var newTemplateEntity = TemplateMyNoSqlEntity.Create(template);
await _templateWriter.InsertAsync(newTemplateEntity);
_logger.LogInformation("Template (ID: {templateId}) doesn't exist, creating the new one.", templateId);
}
}
}
public async ValueTask <bool> CreateBitgoCoinEntityAsync(string coin, int accuracy, int requiredConfirmations, bool isMainNet)
{
if (string.IsNullOrEmpty(coin))
{
throw new Exception("Cannot create coin. Coin cannot be empty");
}
if (accuracy < 0)
{
throw new Exception("Cannot create coin. Accuracy can't be less then 0");
}
if (requiredConfirmations < 0)
{
throw new Exception("Cannot create coin. RequiredConfirmations can't be less then 0");
}
var entity = BitgoCoinEntity.Create(coin, accuracy, requiredConfirmations, isMainNet);
var existingItem = await _bitgoCoins.GetAsync(entity.PartitionKey, entity.RowKey);
if (existingItem != null)
{
throw new Exception("Cannot create coin. Already exist");
}
await _bitgoCoins.InsertAsync(entity);
return(true);
}
public async Task <BitGoUsersList> GetBitGoUsersList()
{
return(new BitGoUsersList()
{
Users = (await _writer.GetAsync())
.Select(e =>
{
e.User.ApiKey = "***";
return e.User;
}).ToList()
});
}
public async Task <BitGoWalletsList> GetBitGoWalletsList()
{
return(new BitGoWalletsList()
{
Wallets = (await _writer.GetAsync())
.Select(e =>
{
e.Wallet.ApiKey = "***";
return e.Wallet;
}).ToList()
});
}
public async Task <List <CountryModel> > GetAllCountries()
{
var entities = await _cache.GetAsync(KycCountryNoSqlEntity.GeneratePartitionKey());
if (entities != null && entities.Any())
{
return(entities.Select(t => t.Country).ToList());
}
await RefreshCache();
await using var context = new DatabaseContext(_dbContextOptionsBuilder.Options);
return(context.Countries.ToList());
}
private async Task <string> SelectProviderByPhone(string phone)
{
var routes = await _writer.GetAsync();
phone = phone
.Replace(" ", "")
.Replace("-", "")
.Replace("(", "")
.Replace(")", "");
if (!phone.StartsWith('+'))
{
phone = $"+{phone}";
}
foreach (var route in routes
.Where(r => !string.IsNullOrEmpty(r.Route.Pattern))
.OrderBy(r => r.Route.Order))
{
var prefixes = route.Route.Pattern.Split(';');
if (prefixes.Contains("*"))
{
return(route.Route.ProviderId);
}
if (prefixes.Any(phone.StartsWith))
{
return(route.Route.ProviderId);
}
}
return(string.Empty);
}
private async Task ProcessQuoteAsync(QuoteMessage quote)
{
var entity = await _priceWriter.GetAsync(Price.GetPk(), quote.AssetPair);
var writerTask = Task.CompletedTask;
if (entity != null)
{
if (quote.IsBuy)
{
entity.Bid = (decimal)quote.Price;
}
else
{
entity.Ask = (decimal)quote.Price;
}
entity.UpdatedDt = quote.Timestamp;
writerTask = _priceWriter.InsertOrReplaceAsync(entity);
}
await Task.WhenAll(
_database.HashSetAsync(RedisService.GetMarketDataKey(quote.AssetPair),
quote.IsBuy ? nameof(MarketSlice.Bid) : nameof(MarketSlice.Ask),
quote.Price.ToString(CultureInfo.InvariantCulture)),
writerTask);
}
private async Task AddVolumeToApiKey(string brokerId, string apiKey, string asset, double amount)
{
try
{
var existingEntity = await _myNoSqlServerApiKeyDataWriter.GetAsync(
ApiKeyVolumeNoSqlEntity.GeneratePartitionKey(brokerId),
ApiKeyVolumeNoSqlEntity.GenerateRowKey(apiKey, asset));
if (existingEntity == null)
{
existingEntity = ApiKeyVolumeNoSqlEntity.Create(new ApiKeyVolume
{
BrokerId = brokerId,
ApiKeyHash = apiKey,
Asset = asset,
Volume = amount,
LastUpdateTime = DateTime.Now
});
}
else
{
existingEntity.Volume.Volume += amount;
existingEntity.Volume.LastUpdateTime = DateTime.Now;
}
await _myNoSqlServerApiKeyDataWriter.InsertOrReplaceAsync(existingEntity);
}
catch (Exception ex)
{
_logger.LogError(ex,
"Unable to update accumulated volume for api key {apiKey}, asset {asset}, amount {amount}", apiKey,
asset, amount);
}
}
public async Task <DateTime> GetLastNotificationDateAsync(string ruleId)
{
var model = await _myNoSqlServerDataWriter.GetAsync(NotificationNoSql.GeneratePartitionKey(),
NotificationNoSql.GenerateRowKey(ruleId));
return(model?.CreatedDate ?? DateTime.MinValue);
}
private async Task ProcessMessageAsync(OrderbookMessage orderbookMessage)
{
OrderbookEntity orderbook = null;
try
{
orderbook = await _orderbookWriter.GetAsync(OrderbookEntity.GetPk(), orderbookMessage.AssetPair);
}
catch (Exception ex)
{
_log.Warning($"Can't get orderbook from mynosql for assetPair = {orderbookMessage.AssetPair}", ex);
}
var entity = orderbook ?? new OrderbookEntity(orderbookMessage.AssetPair)
{
CreatedAt = orderbookMessage.Timestamp
};
entity.CreatedAt = orderbookMessage.Timestamp;
var prices = orderbookMessage.IsBuy ? entity.Bids : entity.Asks;
prices.Clear();
foreach (var price in orderbookMessage.Prices)
{
prices.Add(new VolumePriceEntity((decimal)price.Volume, (decimal)price.Price));
}
await _orderbookWriter.InsertOrReplaceAsync(entity);
}
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 <OperationResponse> CreateWithdrawalProfile(CreateGroupRequest 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
};
withdrawalList.Add(request.ProfileId);
await _profileWriter.InsertOrReplaceAsync(FeeProfilesNoSqlEntity.Create(withdrawalList.Distinct().ToList(), depositList));
if (!string.IsNullOrWhiteSpace(request.CloneFromProfileId))
{
var assets =
(await _assetWriter.GetAsync(
AssetFeesNoSqlEntity.GeneratePartitionKey(request.BrokerId, request.CloneFromProfileId)))
.Select(t => t.AssetFees).ToList();
foreach (var asset in assets)
{
asset.ProfileId = request.ProfileId;
}
await _assetWriter.BulkInsertOrReplaceAsync(assets.Select(AssetFeesNoSqlEntity.Create).ToList());
}
return(new OperationResponse()
{
IsSuccess = true
});
}
catch (Exception e)
{
return(new OperationResponse()
{
IsSuccess = false,
ErrorText = e.Message
});
}
}
public async ValueTask <bool> CreateBitgoAssetMapEntityAsync(string brokerId, string assetSymbol,
string bitgoWalletId, string enabledBitgoWalletIds, string bitgoCoin, double minBalance, string tagSeparator)
{
if (string.IsNullOrEmpty(brokerId))
{
throw new Exception("Cannot create asset map. BrokerId cannot be empty");
}
if (string.IsNullOrEmpty(assetSymbol))
{
throw new Exception("Cannot create asset map. AssetSymbol cannot be empty");
}
if (string.IsNullOrEmpty(bitgoWalletId))
{
throw new Exception("Cannot create asset map. BitgoWalletId cannot be empty");
}
if (string.IsNullOrEmpty(bitgoCoin))
{
throw new Exception("Cannot create asset map. BitgoCoin cannot be empty");
}
var coin = await _bitgoCoins.GetAsync(BitgoCoinEntity.GeneratePartitionKey(),
BitgoCoinEntity.GenerateRowKey(bitgoCoin));
if (coin == null)
{
throw new Exception("Cannot create asset map. Unknown BitgoCoin.");
}
var entity =
BitgoAssetMapEntity.Create(brokerId, assetSymbol, bitgoWalletId, enabledBitgoWalletIds, bitgoCoin, minBalance, tagSeparator);
var existingItem = await _assetMap.GetAsync(entity.PartitionKey, entity.RowKey);
if (existingItem != null)
{
throw new Exception("Cannot create asset map. Already exist");
}
await _assetMap.InsertAsync(entity);
return(true);
}
public async Task <AllRoutesResponse> GetAllRoutesAsync()
{
var routes = await _routeWriter.GetAsync();
var response = new AllRoutesResponse
{
Routes = routes.Select(r => r.Route).ToArray()
};
return(response);
}
public async Task <ProfilesResponse> GetAllProfiles()
{
var groups = await _profileWriter.GetAsync(FeeProfilesNoSqlEntity.GeneratePartitionKey(), FeeProfilesNoSqlEntity.GenerateRowKey());
if (groups.DepositProfiles == null || !groups.DepositProfiles.Any())
{
var list = new List <string>()
{
FeeProfileConsts.DefaultProfile
};
await _profileWriter.InsertOrReplaceAsync(FeeProfilesNoSqlEntity.Create(groups.Profiles, list));
}
return(new ProfilesResponse()
{
WithdrawalProfiles = groups?.Profiles ?? new List <string>(),
DepositProfiles = groups?.DepositProfiles ?? new List <string>()
{
FeeProfileConsts.DefaultProfile
}
});
}
public void Start()
{
var data = _noSqlDataWriter.GetAsync().GetAwaiter().GetResult();
lock (_sync)
{
_data.Clear();
foreach (var item in data)
{
_data[item.Wallet.Name] = item.Wallet;
}
}
}
public async Task <SnapshotEntity> GetSnapshot(string walletId, string assetId)
{
var snapshot = await _writer.GetAsync(SnapshotNoSqlEntity.GeneratePartitionKey(walletId),
SnapshotNoSqlEntity.GenerateRowKey(assetId));
if (snapshot != null)
{
return(snapshot.Entity);
}
await using var ctx = DatabaseContext.Create(_dbContextOptionsBuilder);
var snapshotEntity = await ctx.AvgSnapshots.FirstOrDefaultAsync(t => t.AssetId == assetId && t.WalletId == walletId);
if (snapshotEntity != null)
{
await _writer.InsertOrReplaceAsync(SnapshotNoSqlEntity.Create(snapshotEntity));
await _writer.CleanAndKeepMaxPartitions(Program.Settings.MaxCachedSnapshots);
}
return(snapshotEntity);
}
private async Task ReloadSettings()
{
var settings = (await _settingsDataWriter.GetAsync()).ToList();
var settingsMap = new Dictionary <string, LiquidityConverterSettings>();
foreach (var settingsLiquidityConverterNoSql in settings)
{
settingsMap[settingsLiquidityConverterNoSql.Settings.BrokerId] =
settingsLiquidityConverterNoSql.Settings;
}
_settings = settingsMap;
}
public static async Task <TEntity> TryGetAsync <TEntity>(this IMyNoSqlServerDataWriter <TEntity> writer, string partitionKey, string rowKey) where TEntity : IMyNoSqlDbEntity, new()
{
try
{
var entity = await writer.GetAsync(partitionKey, rowKey);
return(entity);
}
catch (Exception e)
{
if (e.Message.Contains("Row not found"))
{
return(default(TEntity));
}
throw;
}
}
private async Task ProcessMessageAsync(OrderbookMessage orderbookMessage)
{
var entity = await _orderbookWriter.GetAsync(OrderbookEntity.GetPk(), orderbookMessage.AssetPair)
?? new OrderbookEntity(orderbookMessage.AssetPair)
{
CreatedAt = orderbookMessage.Timestamp,
};
entity.CreatedAt = orderbookMessage.Timestamp;
var prices = orderbookMessage.IsBuy ? entity.Bids : entity.Asks;
prices.Clear();
foreach (var price in orderbookMessage.Prices)
{
prices.Add(new VolumePriceEntity((decimal)price.Volume, (decimal)price.Price));
}
await _orderbookWriter.InsertOrReplaceAsync(entity);
}
public async Task <GetAddressInfoResponse> GetWalletIdByAddressAsync(GetAddressInfoRequest request)
{
var entities = await _addressDataWriter.GetAsync();
var entity =
entities.FirstOrDefault(e => e.Address == request.Address && e.AssetSymbol == request.AssetSymbol);
if (entity == null)
{
return(new GetAddressInfoResponse()
{
IsInternalAddress = false
});
}
return(new GetAddressInfoResponse()
{
IsInternalAddress = true,
WalletId = entity.WalletId
});
}
private async Task <string> SendMessageAsync <T>(T request) where T : ISendMessageRequest
{
var partitionKey = TemplateMyNoSqlEntity.GeneratePartitionKey();
var rowKey = TemplateMyNoSqlEntity.GenerateRowKey(request.Type.ToString());
var templateEntity = await _templateWriter.GetAsync(partitionKey, rowKey);
if (templateEntity == null)
{
_logger.LogError("Template with part.key {partitionKey} & row key {rowKey} doesn't exist.", partitionKey, rowKey);
return(null);
}
var brand = request.Brand;
var brandLangBodies = templateEntity.Template.BrandLangBodies.FirstOrDefault(b => b.Brand == brand);
if (brandLangBodies == null)
{
_logger.LogInformation("Template (ID: {templateId}) for brand {brand} doesn't exist, switch to the default brand ({defaultBrand}).",
templateEntity.Template.Id, request.Brand, templateEntity.Template.DefaultBrand);
brand = templateEntity.Template.DefaultBrand;
brandLangBodies = templateEntity.Template.BrandLangBodies.FirstOrDefault(b => b.Brand == brand);
if (brandLangBodies == null)
{
_logger.LogInformation("Template (ID: {templateId}) for default brand ({defaultBrand}) doesn't exist.",
templateEntity.Template.Id, request.Lang, brand);
return(null);
}
}
if (!brandLangBodies.LangBodies.TryGetValue(request.Lang, out var templateBody)) //set brand, set lang
{
_logger.LogInformation("Template (ID: {templateId}) for brand {brand} with lang {lang} doesn't exist, switch to the default lang ({defaultLang}).",
templateEntity.Template.Id, brand, request.Lang, templateEntity.Template.DefaultLang);
if (!brandLangBodies.LangBodies.TryGetValue(templateEntity.Template.DefaultLang, out templateBody)) //set brand, default lang
{
_logger.LogInformation("Template (ID: {templateId}) for the default lang ({defaultLang}) doesn't exist. Switching to default brand ({defaultBrand}) and default lang ({defaultLang})",
templateEntity.Template.Id, templateEntity.Template.DefaultBrand, templateEntity.Template.DefaultLang);
var defaultBrandLangBodies = templateEntity.Template.BrandLangBodies.FirstOrDefault(b => b.Brand == templateEntity.Template.DefaultBrand);
if (!defaultBrandLangBodies.LangBodies.TryGetValue(request.Lang, out templateBody)) //default brand, set lang
{
_logger.LogInformation("Template (ID: {templateId}) for defaultBrand {defaultBrand} with lang {lang} doesn't exist, switch to the default lang ({defaultLang}).",
templateEntity.Template.Id, templateEntity.Template.DefaultBrand, request.Lang, templateEntity.Template.DefaultLang);
if (!defaultBrandLangBodies.LangBodies.TryGetValue(templateEntity.Template.DefaultLang,
out templateBody)) //default brand, default lang
{
_logger.LogError(
"Template (ID: {templateId}) for the default brand ({defaultBrand}) and default lang ({defaultLang}) doesn't exist.",
templateEntity.Template.Id, templateEntity.Template.DefaultBrand,
templateEntity.Template.DefaultLang);
return(null);
}
}
}
}
return(templateBody);
}
public async Task <AuthorizationResponse> RefreshSessionAsync(RefreshSessionRequest request)
{
using var activity = MyTelemetry.StartActivity("Refresh Session");
if (string.IsNullOrEmpty(request.Token) || string.IsNullOrEmpty(request.SignatureBase64))
{
activity.AddTag("message", "bad request");
activity.SetStatus(Status.Error);
return(new AuthorizationResponse()
{
Result = false
});
}
if (DateTime.UtcNow < request.RequestTimestamp || request.RequestTimestamp < DateTime.UtcNow.AddSeconds(-_settings.RequestTimeLifeSec))
{
activity.AddTag("message", "request expired");
activity.SetStatus(Status.Error);
return(new AuthorizationResponse()
{
Result = false
});
}
var(result, token) = TokensManager.ParseBase64Token <JetWalletToken>(request.Token, AuthConst.GetSessionEncodingKey(), DateTime.UtcNow);
if (result != TokenParseResult.Ok && result != TokenParseResult.Expired)
{
activity.AddTag("message", "wrong token");
activity.SetStatus(Status.Error);
return(new AuthorizationResponse()
{
Result = false
});
}
token.Id.AddToActivityAsTag("clientId");
token.BrokerId.AddToActivityAsTag("brokerId");
token.BrandId.AddToActivityAsTag("brandId");
token.WalletId.AddToActivityAsTag("walletId");
token.SessionRootId.AddToActivityAsTag("sessionRootId");
var entity = await _writer.GetAsync(SpotSessionNoSql.GeneratePartitionKey(token.ClientId()), SpotSessionNoSql.GenerateRowKey(token.SessionRootId));
if (entity == null)
{
activity.AddTag("message", "root session do not exist");
activity.SetStatus(Status.Error);
return(new AuthorizationResponse()
{
Result = false
});
}
if (DateTime.UtcNow >= entity.DiedDateTime)
{
activity.AddTag("message", "root session is died");
activity.SetStatus(Status.Error);
return(new AuthorizationResponse()
{
Result = false
});
}
if (DateTime.UtcNow <= entity.CreateDateTime.AddSeconds(_settings.TimeoutToRefreshNewSessionInSec))
{
activity.AddTag("message", "the session is very young, for renewal");
activity.SetStatus(Status.Error);
return(new AuthorizationResponse()
{
Result = false
});
}
var signContent = $"{request.Token}_{request.RequestTimestamp:yyyy-MM-ddTHH:mm:ss}_{request.NewWalletId}";
var verifySignature = MyRsa.ValidateSignature(signContent, request.SignatureBase64, entity.PublicKeyBase64);
if (!verifySignature)
{
activity.AddTag("message", "wrong signature");
activity.SetStatus(Status.Error);
return(new AuthorizationResponse()
{
Result = false
});
}
var walletId = token.WalletId;
if (!string.IsNullOrEmpty(request.NewWalletId))
{
var clientIdentity = new JetClientIdentity(token.BrokerId, token.BrandId, token.Id);
var wallets = await _clientWalletService.GetWalletsByClient(clientIdentity);
var wallet = wallets?.Wallets?.FirstOrDefault(w => w.WalletId == request.NewWalletId);
if (wallet == null)
{
request.NewWalletId.AddToActivityAsTag("walletId");
_logger.LogWarning("Cannot Refresh session, NewWallet do not found. WalletId {walletId}. ClientId: {clientId}", request.NewWalletId, token.Id);
activity.SetStatus(Status.Error);
return(new AuthorizationResponse()
{
Result = false
});
}
walletId = wallet.WalletId;
_logger.LogInformation("Client update session to new walletId. SessionRootId: {sessionRootId}; ClientId: {clientId}; WalletId: {walletId}",
token.SessionRootId, token.Id, walletId);
}
walletId.AddToActivityAsTag("walletId");
var newToken = new JetWalletToken()
{
Id = token.Id,
Expires = DateTime.UtcNow.AddMinutes(_settings.SessionLifeTimeMinutes),
SessionRootId = token.SessionRootId,
SessionId = Guid.NewGuid().ToString("N"),
BrandId = token.BrandId,
BrokerId = token.BrokerId,
WalletId = walletId
};
await _sessionAuditService.RefreshSessionAudit(token, newToken, request.UserAgent, request.Ip);
_logger.LogInformation("Refresh session is success. SessionRootId: {sessionRootId}; SessionId: {sessionId}; PrevSessionId: {prevSessionId}; ClientId: {clientId}; WalletId: {walletId}",
newToken.SessionRootId, newToken.SessionId, token.SessionId, newToken.ClientId(), newToken.WalletId);
return(new AuthorizationResponse()
{
Token = newToken.IssueTokenAsBase64String(AuthConst.GetSessionEncodingKey()),
Result = true
});
}
public async Task <List <SpotInstrumentFees> > GetSpotInstrumentFeesSettingsList()
{
var entities = await _writer.GetAsync();
return(entities.Select(e => e.SpotInstrumentFees).ToList());
}
public async Task <List <FeesSettings> > GetFeesSettingsList()
{
var entities = await _writer.GetAsync();
return(entities.Select(e => e.FeesSettings).ToList());
}
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 <IEnumerable <NotificationChannel> > GetAsync()
{
var models = await _myNoSqlServerDataWriter.GetAsync();
return(models.Select(m => m.Value));
}
public async Task <List <PositionPortfolio> > GetAll()
{
var data = await _dataWriter.GetAsync();
return(data.Select(e => e.Position).ToList());
}
