public async Task <string> RegisterAsync(ITweetCash tweetCash)
{
var newItem = TweetCash.Create(tweetCash);
await _tableStorage.InsertAsync(newItem);
return(newItem.TweetId);
}
public Task SaveAsync(string clientId, string sessionId, string clientInfo)
{
return(Task.WhenAll(
_tableStorage.InsertAsync(ClientSessionEntity.CreateByToken(clientId, sessionId, clientInfo)),
_tableStorage.InsertAsync(ClientSessionEntity.CreateByClient(clientId, sessionId, clientInfo))
));
}
public async Task RegisterOrderAsync(OrderBase order)
{
var newEntity = OrderEntity.Create(order);
await _tableStorage.InsertAsync(newEntity);
newEntity.PartitionKey = OrderEntity.GeneratePartitionKey(order.TraderId);
await _tableStorage.InsertAsync(newEntity);
}
public Task InsertAsync(HedgeLimitOrder hedgeLimitOrder)
{
var entity = new HedgeLimitOrderEntity(GetPartitionKey(hedgeLimitOrder.Id), GetRowKey(hedgeLimitOrder.Id));
Mapper.Map(hedgeLimitOrder, entity);
return(_storage.InsertAsync(entity));
}
public async Task SaveAsync(IBcnCredentialsRecord credsRecord)
{
var byClientEntity = BcnCredentialsRecordEntity.ByClientId.Create(credsRecord);
var byAssetAddressEntity = BcnCredentialsRecordEntity.ByAssetAddress.Create(credsRecord);
await _tableStorage.InsertAsync(byClientEntity);
await _tableStorage.InsertAsync(byAssetAddressEntity);
}
public async Task <IOffchainTransfer> CreateTransfer(string transactionId, string clientId, string assetId, decimal amount, OffchainTransferType type, string externalTransferId, string orderId, bool channelClosing = false)
{
var entity = OffchainTransferEntity.ByCommon.Create(transactionId, clientId, assetId, amount, type, externalTransferId, orderId, channelClosing);
var byClient = OffchainTransferEntity.ByClient.Create(entity);
await Task.WhenAll(_storage.InsertAsync(entity), _storage.InsertAsync(byClient));
return(entity);
}
public async Task CreateAsync(IMarketOrder marketOrder)
{
var byOrderEntity = MarketOrderEntity.ByOrderId.Create(marketOrder);
var byClientEntity = MarketOrderEntity.ByClientId.Create(marketOrder);
await _tableStorage.InsertAsync(byOrderEntity);
await _tableStorage.InsertAsync(byClientEntity);
}
public async Task <string> AddAsync(SmsMessage message)
{
var entity = SmsMessageEntity.Create(message);
await _tableStorage.TryInsertAsync(entity);
var indexEntity = AzureIndex.Create(IdIndex, entity.Id, entity);
await _index.InsertAsync(indexEntity);
return(entity.Id);
}
public async Task InsertAsync(IEthereumTransactionRequest request, bool insertOrder = true)
{
var entityById = EthereumTransactionReqEntity.ById.Create(request);
await _tableStorage.InsertAsync(entityById);
if (insertOrder && !string.IsNullOrEmpty(request.OrderId))
{
var entitByOrder = EthereumTransactionReqEntity.ByOrderId.Create(request);
await _tableStorage.InsertAsync(entitByOrder);
}
}
private async Task <EmailTokenEntity> GenerateNewToken(string email)
{
var newEntity = EmailTokenEntity.Create(email);
await _tableStorage.InsertAsync(newEntity);
var newIndex = EmailTokenEntity.GenerateTokenIndex(newEntity);
await _tableStorage.InsertAsync(newIndex);
return(newEntity);
}
public async Task <IOffchainRequest> CreateRequest(string transferId, string clientId, string assetId, RequestType type, OffchainTransferType transferType)
{
var id = Guid.NewGuid().ToString();
var byClient = OffchainRequestEntity.ByClient.Create(id, transferId, clientId, assetId, type, transferType);
await _table.InsertAsync(byClient);
var byRecord = OffchainRequestEntity.ByRecord.Create(id, transferId, clientId, assetId, type, transferType);
await _table.InsertAsync(byRecord);
return(byRecord);
}
public async Task InsertAsync(Order order)
{
var entity = new OrderEntity(GetPartitionKey(order.WalletId), GetRowKey(order.Id));
Mapper.Map(order, entity);
await _storage.InsertThrowConflictAsync(entity);
var index = new AzureIndex(GetIndexPartitionKey(order.Status), GetIndexRowKey(order.Id), entity);
await _indices.InsertAsync(index);
}
public async Task <Employee> InsertAsync(Employee employee)
{
var entity = new EmployeeEntity(GetPartitionKey(employee.MerchantId), CreateRowKey());
Mapper.Map(employee, entity);
await _storage.InsertAsync(entity);
var emailIndex = AzureIndex.Create(GetEmailIndexPartitionKey(), GetEmailIndexRowKey(entity.Email), entity);
await _indexStorage.InsertAsync(emailIndex);
return(Mapper.Map <Employee>(entity));
}
public async Task ShouldGetAll()
{
var quotes = new[]
{
new FixQuoteEntity("rur", 1, 2, DateTime.Now, DateTime.Now.AddDays(1)),
new FixQuoteEntity("usd", 1, 2, DateTime.Now, DateTime.Now.AddDays(1))
};
await _storage.InsertAsync(quotes);
var resutl = await _repository.GetAllAsync(DateTime.Now);
Assert.That(resutl.Count, Is.EqualTo(2));
Assert.That(resutl.Count(s => s.AssetPair == _rur.AssetPair), Is.EqualTo(1));
Assert.That(resutl.Count(s => s.AssetPair == _usd.AssetPair), Is.EqualTo(1));
}
public async Task AddAsync(
Transaction transaction)
{
var(partitionKey, rowKey) = GetTransactionKeys(transaction.TransactionId);
var transactionEntity = new TransactionEntity
{
Amount = transaction.Amount,
BlockNumber = transaction.BlockNumber,
BroadcastedOn = transaction.BroadcastedOn,
BuiltOn = transaction.BuiltOn,
CompletedOn = transaction.CompletedOn,
Data = transaction.Data,
DeletedOn = transaction.DeletedOn,
Error = transaction.Error,
From = transaction.From,
GasAmount = transaction.GasAmount,
GasPrice = transaction.GasPrice,
Hash = transaction.Hash,
IncludeFee = transaction.IncludeFee,
SignedData = transaction.SignedData,
State = transaction.State,
To = transaction.To,
TransactionId = transaction.TransactionId,
PartitionKey = partitionKey,
RowKey = rowKey
};
await _transactions.InsertAsync(transactionEntity);
}
public static async Task <T> ModifyOrCreateAsync <T>(this INoSQLTableStorage <T> tableStorage,
string partitionKey, string rowKey, Func <T> create, Action <T> update) where T : ITableEntity, new()
{
for (var i = 0; i < 15; i++)
{
try
{
var entity = await tableStorage.ReplaceAsync(partitionKey, rowKey, itm =>
{
update(itm);
return(itm);
});
if (entity != null)
{
return(entity);
}
entity = create();
await tableStorage.InsertAsync(entity);
return(entity);
}
catch (Exception)
{
}
}
throw new Exception("Can not modify or update entity: " + PrintItem(create()));
}
public async Task <string> RegisterAsync(ITwitterAppAccount twitterAppAccount)
{
var newItem = TwitterAppAccount.Create(twitterAppAccount);
await _tableStorage.InsertAsync(newItem);
return(newItem.Id);
}
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 AddIfMissingMultipleAsync(IEnumerable <ITrade> trades)
{
if (trades == null || !trades.Any())
{
return;
}
var tradesToWrite = new List <ITrade>();
foreach (var trade in trades)
{
if (await GetAsync(trade.Id) == null)
{
tradesToWrite.Add(trade);
}
}
if (!tradesToWrite.Any())
{
return;
}
var entities = tradesToWrite.Select(TradeLogEntity.Create).ToArray();
await _tableStorage.InsertAsync(entities);
await _idIndexStorage.InsertAsync(entities.Select(t => AzureIndex.Create(IndexId, t.Id, t.PartitionKey, t.RowKey)));
}
public async Task InsertAsync(InvoiceDispute invoiceDispute)
{
var entity = new InvoiceDisputeEntity(GetPartitionKey(invoiceDispute.InvoiceId), GetRowKey(invoiceDispute.CreatedAt));
Mapper.Map(invoiceDispute, entity);
await _storage.InsertAsync(entity);
}
public static async Task <T> InsertOrModifyAsync <T>(this INoSQLTableStorage <T> tableStorage, string partitionKey,
string rowKey, Func <T> createNew, Func <T, T> modify)
where T : class, ITableEntity, new()
{
for (var i = 0; i < 100; i++)
{
try
{
var result = await tableStorage.ReplaceAsync(partitionKey,
rowKey, modify);
if (result != null)
{
return(result);
}
result = createNew();
await tableStorage.InsertAsync(result);
return(result);
}
catch
{
}
}
throw new Exception("Can not insert or modify entity");
}
public async Task <IEmailVerificationCode> CreateAsync(string email, string partnerId, bool generateRealCode)
{
var entity = _emailVerificationCodeFactory.CreateEmailVerificationCode(email, partnerId, generateRealCode);
await _tableStorage.InsertAsync(entity);
return(entity);
}
public async Task <IOffchainOrder> CreateOrder(string clientId, string asset, string assetPair, decimal volume, bool straight)
{
var entity = OffchainOrder.Create(clientId, asset, assetPair, volume, straight);
await _storage.InsertAsync(entity);
return(entity);
}
public async Task <string> SaveAsync(IProjectData projectData)
{
var newEntity = ProjectEntity.Create(projectData);
await _projectsTableStorage.InsertAsync(newEntity);
return(newEntity.Id);
}
public async Task <IVirtualWallet> CreateAsync(IVirtualWallet wallet)
{
VirtualWalletEntity entity = VirtualWalletEntity.ByMerchantId.Create(wallet);
await _tableStorage.InsertAsync(entity);
AzureIndex indexByWalletId = VirtualWalletEntity.IndexByWalletId.Create(entity);
await _walletIdIndexStorage.InsertAsync(indexByWalletId);
AzureIndex indexByDueDate = VirtualWalletEntity.IndexByDueDate.Create(entity);
await _dueDateIndexStorage.InsertAsync(indexByDueDate);
return(Mapper.Map <VirtualWallet>(entity));
}
public async Task <string> InsertRequestAsync <T>(ICashOutRequest request, PaymentSystem paymentSystem, T paymentFields, CashOutRequestTradeSystem tradeSystem)
{
var entity = CashOutAttemptEntity.PendingRecords.Create(request, paymentSystem, paymentFields, tradeSystem);
await _tableStorage.InsertAsync(entity);
return(entity.RowKey);
}
public async Task <ISmsVerificationCode> CreateAsync(string partnerId, string phoneNum, bool generateRealCode)
{
var entity = _smsVerificationCodeFactory.CreateSmsVerificationCode(phoneNum, partnerId, generateRealCode);
await _tableStorage.InsertAsync(entity);
return(entity);
}
public async Task <IKycDocument> AddAsync(IKycDocument kycDocument)
{
var newDocument = KycDocumentEntity.Create(kycDocument);
await _tableStorage.InsertAsync(newDocument);
return(newDocument);
}
public async Task AddAsync(IExpiryEntry entry)
{
var alreadyExisted = !await
_tableStorage.TryInsertAsync(
new ExpiryEntryEntity
{
PartitionKey = ExpiryEntryEntity.ByClient.GeneratePartitionKey(entry.ClientId),
RowKey = ExpiryEntryEntity.ByClient.GenerateRowKey(entry.RequestId),
ClientId = entry.ClientId,
RequestId = entry.RequestId,
ExpiryDateTime = entry.ExpiryDateTime
});
if (!alreadyExisted)
{
await _tableStorage.InsertAsync(
new ExpiryEntryEntity
{
PartitionKey = ExpiryEntryEntity.ByDateTime.GeneratePartitionKey(),
RowKey = ExpiryEntryEntity.ByDateTime.GenerateRowKey(entry.ExpiryDateTime, entry.RequestId),
ClientId = entry.ClientId,
RequestId = entry.RequestId,
ExpiryDateTime = entry.ExpiryDateTime
});
}
}
public async Task <IEnumerable <IAccountAssetPair> > AddAssetPairs(string tradingConditionId, string baseAssetId,
IEnumerable <string> assetPairsIds, AccountAssetsSettings defaults)
{
var entitiesToAdd = assetPairsIds.Select(x => AccountAssetPairEntity.Create(
new AccountAssetPair
{
BaseAssetId = baseAssetId,
TradingConditionId = tradingConditionId,
Instrument = x,
CommissionLong = defaults.CommissionLong,
CommissionLot = defaults.CommissionLot,
CommissionShort = defaults.CommissionShort,
DealLimit = defaults.DealLimit,
DeltaAsk = defaults.DeltaAsk,
DeltaBid = defaults.DeltaBid,
LeverageInit = defaults.LeverageInit,
LeverageMaintenance = defaults.LeverageMaintenance,
PositionLimit = defaults.PositionLimit,
SwapLong = defaults.SwapLong,
SwapShort = defaults.SwapShort,
OvernightSwapLong = defaults.OvernightSwapLong,
OvernightSwapShort = defaults.OvernightSwapShort
})).ToArray();
await _tableStorage.InsertAsync(entitiesToAdd);
return(entitiesToAdd);
}
