public async Task <ICustomerChecksInfo> UpdateCheckStatesAsync(string clientId, bool?pep = null, bool?crime = null, bool?sanction = null)
{
var entity = CustomerChecksInfoEntity.Create(clientId, pep, crime, sanction);
await _tableStorage.InsertOrMergeAsync(entity);
return(entity);
}
public async Task SaveConnectionUrlHistoryAsync(
string repositoryId,
string ip,
string userAgent)
{
var id = Guid.NewGuid().ToString();
var commonPk = new ConnectionUrlHistory
{
PartitionKey = ConnectionUrlHistory.GeneratePartitionKey(),
RowKey = id,
RepositoryId = repositoryId,
Ip = ip,
UserAgent = userAgent,
};
var repoPk = new ConnectionUrlHistory
{
PartitionKey = repositoryId,
RowKey = id,
RepositoryId = repositoryId,
Ip = ip,
UserAgent = userAgent,
};
var tasks = new List <Task>
{
_tableStorage.InsertOrMergeAsync(commonPk),
_tableStorage.InsertOrMergeAsync(repoPk),
};
await Task.WhenAll(tasks);
if (_totalCount.HasValue)
{
_totalCount = _totalCount.Value + 1;
}
}
public async Task EditGroup(IAssetGroup assetGroup)
{
var entity = AssetGroupEntity.Record.Create(assetGroup);
await _tableStorage.InsertOrMergeAsync(entity);
var updatedGroup = await _tableStorage.GetDataAsync(AssetGroupEntity.Record.GeneratePartitionKey(),
AssetGroupEntity.Record.GenerateRowKey(assetGroup.Name));
var clients = (await GetClientIdsForGroup(assetGroup.Name)).ToArray();
if (clients.Any())
{
foreach (var clientId in clients)
{
var clientGroupLink = await _tableStorage
.GetDataAsync(AssetGroupEntity.ClientGroupLink.GeneratePartitionKey(updatedGroup.Name),
AssetGroupEntity.ClientGroupLink.GenerateRowKey(clientId));
AssetGroupEntity.ClientGroupLink.Update(clientGroupLink, updatedGroup);
var groupClientLink = await _tableStorage
.GetDataAsync(AssetGroupEntity.GroupClientLink.GeneratePartitionKey(clientId),
AssetGroupEntity.GroupClientLink.GenerateRowKey(updatedGroup.Name));
AssetGroupEntity.GroupClientLink.Update(groupClientLink, updatedGroup);
await _tableStorage.InsertOrMergeAsync(clientGroupLink);
await _tableStorage.InsertOrMergeAsync(groupClientLink);
}
}
}
public async Task SaveKeyValueOverrideHistoryAsync(
string keyValueId,
string newOverride,
string keyValues,
string userName,
string userIpAddress)
{
var datetime = DateTime.UtcNow.StorageString();
var th = new KeyValueHistory
{
PartitionKey = keyValueId,
RowKey = datetime,
DateTime = datetime,
KeyValueId = keyValueId,
NewOverride = newOverride,
UserName = userName,
UserIpAddress = userIpAddress
};
th.KeyValuesSnapshot = $"{th.UserName}_{th.RowKey}_{th.UserIpAddress}";
await _blobStorage.SaveBlobAsync(_container, th.KeyValuesSnapshot, Encoding.UTF8.GetBytes(keyValues));
await _tableStorage.InsertOrMergeAsync(th);
}
public async Task AssignDialogToClientAsync(string clientId, string dialogId)
{
var index = CreateClientDialogIndex(clientId, dialogId);
var dialogIndex = CreateDialogIndex(clientId, dialogId);
var tasks = new List <Task>
{
_clientDialogIndex.InsertOrMergeAsync(index),
_clientDialogIndex.InsertOrMergeAsync(dialogIndex)
};
await Task.WhenAll(tasks);
}
public async Task SetJsonPageLockAsync(string userEmail, string userName, string ipAddress)
{
var pk = LockEntity.GeneratePartitionKey();
await _tableStorage.InsertOrMergeAsync(new LockEntity
{
PartitionKey = pk,
RowKey = JsonLockKey,
UserEmail = userEmail,
DateTime = DateTime.UtcNow,
UserName = userName,
IpAddress = ipAddress,
ETag = "*"
});
}
public async Task InsertOrMergeAsync(IFeedCandle candle, PriceType priceType, TimeInterval interval)
{
// Get candle table entity
var partitionKey = CandleTableEntity.GeneratePartitionKey(priceType);
var rowKey = CandleTableEntity.GenerateRowKey(candle.DateTime, interval);
var entity = await _tableStorage.GetDataAsync(partitionKey, rowKey) ??
new CandleTableEntity(partitionKey, rowKey);
// Merge candle
entity.MergeCandle(candle, interval);
// Update
await _tableStorage.InsertOrMergeAsync(entity);
}
public async Task CreateInitialAdminAsync(string defaultUserEmail, string defaultUserPasswordHash)
{
var usr = new UserEntity
{
PartitionKey = UserEntity.GeneratePartitionKey(),
RowKey = defaultUserEmail,
Email = defaultUserEmail,
PasswordHash = defaultUserPasswordHash,
FirstName = "Admin",
LastName = "Initial",
Active = true,
Admin = true
};
await _tableStorage.InsertOrMergeAsync(usr);
}
public async Task <ITextResource> AddAsync(string lang, string name, string value)
{
var entity = TextResourceEntity.Create(lang, name, value);
await _tableStorage.InsertOrMergeAsync(entity);
return(entity);
}
public async Task <IAssetAvailabilityByMerchant> SetAsync(string paymentAssets, string settlementAssets, string merchantId)
{
string partitionKey = AssetAvailabilityByMerchantEntity.GeneratePartitionKey(merchantId);
string rowKey = AssetAvailabilityByMerchantEntity.GenerateRowKey(merchantId);
AssetAvailabilityByMerchantEntity exItem = await _tableStorage.GetDataAsync(partitionKey, rowKey);
if (exItem != null && string.IsNullOrEmpty(settlementAssets) && string.IsNullOrEmpty(paymentAssets))
{
await _tableStorage.DeleteAsync(exItem);
return(null);
}
if (exItem != null)
{
exItem.PaymentAssets = paymentAssets;
exItem.SettlementAssets = settlementAssets;
await _tableStorage.InsertOrMergeAsync(exItem);
return(exItem);
}
var newItem = AssetAvailabilityByMerchantEntity.Create(new AssetAvailabilityByMerchant
{
MerchantId = merchantId,
PaymentAssets = paymentAssets,
SettlementAssets = settlementAssets
});
await _tableStorage.InsertAsync(newItem);
return(newItem);
}
public async Task <bool> SaveAsync(IServiceTokenEntity token)
{
try
{
var pk = ServiceTokenEntity.GeneratePartitionKey();
var sToken = await _tableStorage.GetDataAsync(pk, token.RowKey);
var sNewToken = (ServiceTokenEntity)token;
if (sToken == null)
{
sToken = new ServiceTokenEntity
{
PartitionKey = ServiceTokenEntity.GeneratePartitionKey(),
RowKey = token.RowKey,
ETag = token.ETag
};
}
sToken.SecurityKeyOne = sNewToken.SecurityKeyOne;
sToken.SecurityKeyTwo = sNewToken.SecurityKeyTwo;
await _tableStorage.InsertOrMergeAsync(sToken);
}
catch
{
return(false);
}
return(true);
}
public async Task <IGroupResource> AddAsync(IGroupResource resource)
{
var entity = GroupResourceEntity.Create(resource);
await _tableStorage.InsertOrMergeAsync(entity);
return(entity);
}
public Task UpdateEntity(string xApiKey, Order order)
{
var entity = LimitOrderEntity.ByOrder.Create(order, xApiKey);
entity.Timestamp = DateTimeOffset.UtcNow;
return(_storage.InsertOrMergeAsync(entity));
}
public async Task <bool> SaveUser(IUserEntity user)
{
try
{
var userEntity = await GetUserByUserEmail(user.Email);
var te = (UserEntity)user;
if (userEntity == null)
{
te.RowKey = UserEntity.GenerateRowKey(te.Email);
}
else
{
te.RowKey = userEntity.RowKey;
}
if (te.PartitionKey == null)
{
te.PartitionKey = UserEntity.GeneratePartitionKey();
}
await _tableStorage.InsertOrMergeAsync(te);
}
catch (Exception e)
{
Console.WriteLine(e);
return(false);
}
return(true);
}
public async Task SaveRepositoryUpdateHistory(IRepositoryUpdateHistory entity)
{
if (entity is RepositoryUpdateHistoryEntity ruh)
{
if (ruh.CreatedAt == null)
{
ruh.CreatedAt = DateTimeOffset.UtcNow;
}
ruh.PartitionKey = RepositoryUpdateHistoryEntity.GeneratePartitionKey();
ruh.RowKey = entity.RepositoryId;
}
else
{
var pk = RepositoryUpdateHistoryEntity.GeneratePartitionKey();
var rk = RepositoryUpdateHistoryEntity.GenerateRowKey(entity.RepositoryId);
ruh = await _tableStorage.GetDataAsync(pk, rk)
?? new RepositoryUpdateHistoryEntity
{
PartitionKey = pk, RowKey = rk
};
ruh.RepositoryId = entity.RepositoryId;
ruh.InitialCommit = entity.InitialCommit;
ruh.User = entity.User;
ruh.Branch = entity.Branch;
ruh.IsManual = entity.IsManual;
ruh.CreatedAt = DateTime.UtcNow;
}
await _tableStorage.InsertOrMergeAsync(ruh);
}
public async Task <IClientDialog> AddDialogAsync(IClientDialog clientDialog)
{
var entity = ClientDialogEntity.Create(clientDialog);
await _tableStorage.InsertOrMergeAsync(entity);
return(entity);
}
public async Task <ILanguage> AddAsync(string code, string name)
{
var entity = LanguageEntity.Create(code, name);
await _tableStorage.InsertOrMergeAsync(entity);
return(entity);
}
public async Task <string> AddAsync(IQuestion question)
{
var entity = QuestionEntity.Create(question);
await _tableStorage.InsertOrMergeAsync(entity);
return(entity.Id);
}
public async Task SaveRepositoryAsync(IRepository repository)
{
if (repository is RepositoryEntity rs)
{
rs.PartitionKey = RepositoryEntity.GeneratePartitionKey();
rs.RowKey = repository.RepositoryId;
}
else
{
var pk = RepositoryEntity.GeneratePartitionKey();
var rk = RepositoryEntity.GenerateRowKey(repository.RepositoryId);
rs = await _tableStorage.GetDataAsync(pk, rk)
?? new RepositoryEntity
{
PartitionKey = pk, RowKey = rk
};
rs.Name = repository.Name;
rs.GitUrl = repository.GitUrl;
rs.Branch = repository.Branch;
rs.FileName = repository.FileName;
rs.UserName = repository.UserName;
rs.ConnectionUrl = repository.ConnectionUrl;
rs.UseManualSettings = repository.UseManualSettings;
rs.Tag = repository.Tag;
}
await _tableStorage.InsertOrMergeAsync(rs);
}
public async Task SaveApplicationSettings(IApplicationSettingsEntity entity)
{
if (!(entity is ApplicationSettingsEntity se))
{
se = new ApplicationSettingsEntity
{
ETag = entity.ETag,
AzureClientId = entity.AzureClientId,
AzureRegionName = entity.AzureRegionName,
AzureClientKey = entity.AzureClientKey,
AzureTenantId = entity.AzureTenantId,
AzureResourceGroupName = entity.AzureResourceGroupName,
AzureStorageName = entity.AzureStorageName,
AzureKeyName = entity.AzureKeyName,
AzureSubscriptionId = entity.AzureSubscriptionId,
AzureApiKey = entity.AzureApiKey,
DefaultMongoDBConnStr = entity.DefaultMongoDBConnStr,
DefaultRabbitMQConnStr = entity.DefaultRabbitMQConnStr,
DefaultRedisConnStr = entity.DefaultRedisConnStr
};
}
se.PartitionKey = ApplicationSettingsEntity.GeneratePartitionKey();
se.RowKey = entity.RowKey;
await _tableStorage.InsertOrMergeAsync(se);
}
public async Task UpdateAsync(LimitOrder limitOrder)
{
var entity = new LimitOrderEntity(GetPartitionKey(limitOrder.AssetPairId), GetRowKey(limitOrder.Id));
Mapper.Map(limitOrder, entity);
await _storage.InsertOrMergeAsync(entity);
}
public async Task <IPaymentCallback> SetAsync(IPaymentCallback paymentCallback)
{
var entity = PaymentCallbackEntity.ByMerchant.Create(paymentCallback);
await _tableStorage.InsertOrMergeAsync(entity);
return(Mapper.Map <PaymentCallback>(entity));
}
public Task UpdateLimitOrdersCount(string clientId, int count)
{
var entity = ClientCacheEntity.Create(clientId);
entity.LimitOrdersCount = count;
return(_storage.InsertOrMergeAsync(entity));
}
public async Task <IGoogle2FaSecret> UpdateAsync(string clientId, bool isActive)
{
var entity = await _tableStorage.GetDataAsync(
Google2FaSecretEntity.GeneratePartitionKey(),
clientId);
if (entity == null)
{
throw new InvalidOperationException();
}
entity.IsActive = isActive;
await _tableStorage.InsertOrMergeAsync(entity);
return(entity);
}
public async Task UpdateAsync(OrderBookTrader orderBookTrader)
{
var entity = new OrderBookEntity(GetPartitionKey(), GetRowKey(orderBookTrader.AssetPairId));
Mapper.Map(orderBookTrader, entity);
await _storage.InsertOrMergeAsync(entity);
}
public async Task CreateOrUpdateAsync(DefaultSetting setting)
{
var entity = new DefaultSettingsEntity(GetPartitionKey(), GetRowKey());
Mapper.Map(setting, entity);
await _storage.InsertOrMergeAsync(entity);
}
public async Task SetSettingAsync(string key, string value)
{
await _table.InsertOrMergeAsync(new AppSettingEntity
{
PartitionKey = AppSettingEntity.GeneratePartitionKey(),
RowKey = key,
Value = value
});
}
public Task Add(string clientId, string id, string url)
{
return(_tableStorage.InsertOrMergeAsync(new HistoryExportEntry
{
PartitionKey = clientId,
RowKey = id,
Url = url
}));
}
public async Task SaveKeyValueHistoryAsync(string keyValueId, string newValue, string keyValues, string userName,
string userIpAddress, DateTime atDate)
{
var th = new KeyValueHistory
{
KeyValueId = keyValueId,
NewValue = newValue,
PartitionKey = KeyValueHistory.GeneratePartitionKey(),
RowKey = atDate.StorageString(),
UserName = userName,
UserIpAddress = userIpAddress
};
th.KeyValuesSnapshot = $"{th.UserName}_{th.RowKey}_{th.UserIpAddress}";
await _blobStorage.SaveBlobAsync(_container, th.KeyValuesSnapshot, Encoding.UTF8.GetBytes(keyValues));
await _tableStorage.InsertOrMergeAsync(th);
}
public Task AddLogAsync <T>(string author, string entityId, string entityName, string change) where T : class
{
var entity = AuditLogEntity.Create <T>(author, entityId, entityName, change);
var authorIndex = AzureIndex.Create(AuditLogEntity.GenerateAuthorIndexPk(author), Guid.NewGuid().ToString(), entity.PartitionKey, entity.RowKey);
return(Task.WhenAll(
_tableStorage.InsertOrMergeAsync(entity),
_authorIndex.InsertOrMergeAsync(authorIndex)
));
}
