예제 #1
0
        public async Task UpdateOrderAsync(OrderBase updatedOrder)
        {
            var partitionKey = OrderEntity.GeneratePartitionKey(updatedOrder.TraderId);
            var rowKey       = OrderEntity.GenerateRowKey(updatedOrder.Id);


            var oldStatus = OrderStatus.Registered;

            await _tableStorage.ReplaceAsync(partitionKey, rowKey, itm =>
            {
                oldStatus = itm.GetOrder().Status;
                itm.SetOrder(updatedOrder);
                return(itm);
            });



            if (oldStatus == updatedOrder.Status)
            {
                await _tableStorage.ReplaceAsync(OrderEntity.GeneratePartitionAsAllOrders(oldStatus), rowKey, itm =>
                {
                    itm.SetOrder(updatedOrder);
                    return(itm);
                });

                return;
            }


            partitionKey = OrderEntity.GeneratePartitionAsAllOrders(oldStatus);
            await _tableStorage.DeleteAsync(partitionKey, rowKey);

            var newEntity = OrderEntity.Create(updatedOrder);
            await _tableStorage.InsertOrReplaceAsync(newEntity);
        }
예제 #2
0
        public async Task <T> ReplaceAsync(string partitionKey, string rowKey, Func <T, T> replaceAction)
        {
            var result = await _table.ReplaceAsync(partitionKey, rowKey, replaceAction);

            await _cache.ReplaceAsync(partitionKey, rowKey, replaceAction);

            return(result);
        }
예제 #3
0
 public Task SetBalance(string address, BigInteger balance)
 {
     return(_storage.ReplaceAsync(UserContractEntity.GeneratePartitionKey(), address, entity =>
     {
         entity.BalanceStr = balance.ToString();
         entity.LastCheck = DateTime.UtcNow;
         return entity;
     }));
 }
예제 #4
0
        public Task ChangePhoneAsync(string clientId, string phoneNumber)
        {
            var partitionKey = ClientAccountEntity.GeneratePartitionKey();
            var rowKey       = ClientAccountEntity.GenerateRowKey(clientId);

            return(_clientsTablestorage.ReplaceAsync(partitionKey, rowKey, itm =>
            {
                itm.Phone = phoneNumber;
                return itm;
            }));
        }
예제 #5
0
        public Task ChangeFullNameAsync(string id, string fullName)
        {
            var partitionKey = PersonalDataEntity.GeneratePartitionKey();
            var rowKey       = PersonalDataEntity.GenerateRowKey(id);

            return(_tableStorage.ReplaceAsync(partitionKey, rowKey, itm =>
            {
                itm.FullName = fullName;
                return itm;
            }));
        }
예제 #6
0
        public Task SetStatus(string address, ReportStatus status)
        {
            return(_storage.ReplaceAsync(BaseReportMetadataEntity.GeneratePartitionKey(),
                                         BaseReportMetadataEntity.GenerateRowKey(address),
                                         p =>
            {
                p.Status = status.ToString();

                return p;
            }));
        }
 public async Task CompleteTransfer(string transferId, bool?onchain = null)
 {
     await _storage.ReplaceAsync(OffchainTransferEntity.ByCommon.GeneratePartitionKey(), transferId,
                                 entity =>
     {
         entity.Completed = true;
         if (onchain != null)
         {
             entity.Onchain = onchain.Value;
         }
         return(entity);
     });
 }
        public Task <TEntity> ReplaceAsync(string partitionKey, string rowKey, Func <TEntity, TEntity> replaceAction)
        {
            object result = "Not read";

            return(WrapAsync(() => _impl.ReplaceAsync(partitionKey, rowKey, entity =>
            {
                var replacedItem = replaceAction(entity);
                result = replacedItem;
                return replacedItem;
            }),
                             nameof(ReplaceAsync),
                             result));
        }
예제 #9
0
 public async Task SetChildFlags(IEnumerable <ICoinTransaction> transactions, List <string> clients)
 {
     foreach (var coinTransaction in transactions)
     {
         coinTransaction.HasChildClientA = clients.Contains(coinTransaction.ClientA);
         coinTransaction.HasChildClientB = clients.Contains(coinTransaction.ClientB);
         await _table.ReplaceAsync(CoinTransationEntity.Key, coinTransaction.RequestId.ToString(), entity =>
         {
             entity.HasChildClientA = coinTransaction.HasChildClientA;
             entity.HasChildClientB = coinTransaction.HasChildClientB;
             return(entity);
         });
     }
 }
        public virtual async Task ReplaceAsync(TD obj)
        {
            var entity = ConvertService.Convert <TD, TE>(obj, DefaultAzureMappingOpts);

            entity.SetKeys();
            await TableStorage.ReplaceAsync(entity);
        }
예제 #11
0
        public async Task Save <TData>(IOperationExecutionInfo <TData> executionInfo) where TData : class
        {
            var entity = Convert(executionInfo);

            entity.LastModified = _dateService.Now();
            await _tableStorage.ReplaceAsync(entity);
        }
        public async Task ReplaceAsync(IMerchant merchant)
        {
            var entity = new MerchantEntity(
                MerchantEntity.ById.GeneratePartitionKey(merchant.Name),
                MerchantEntity.ById.GenerateRowKey(merchant.Name));

            Mapper.Map(merchant, entity);

            entity.ETag = "*";

            await _storage.ReplaceAsync(entity);

            if (!string.IsNullOrEmpty(merchant.Email))
            {
                var existingEmailIndex = await _emailIndexStorage.GetDataAsync(
                    MerchantEntity.IndexByEmail.GeneratePartitionKey(merchant.Email),
                    MerchantEntity.IndexByEmail.GenerateRowKey());

                if (existingEmailIndex == null)
                {
                    var newEmailIndex = MerchantEntity.IndexByEmail.Create(entity);

                    await _emailIndexStorage.InsertThrowConflict(newEmailIndex);
                }
            }
        }
예제 #13
0
        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");
        }
예제 #14
0
        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 Save <TData>(IOperationExecutionInfo <TData> executionInfo) where TData : class
        {
            var entity = Convert(executionInfo);

            entity.LastModified = _systemClock.UtcNow.UtcDateTime;
            await _tableStorage.ReplaceAsync(entity);
        }
예제 #16
0
        public async static Task<T> ReplaceAsync<T>(this INoSQLTableStorage<T> tableStorage, IAzureIndex index, Func<T, T> action) where T : class, ITableEntity, new()
        {
            if (index == null)
                return null;

            return await tableStorage.ReplaceAsync(index.PrimaryPartitionKey, index.PrimaryRowKey, action);
        }
        public async Task UpdateHotWallet(string asset, string hotWallet)
        {
            var entity = await _table.GetDataAsync(AssetSettingEntity.ById.GeneratePartition(), asset);

            if (entity != null)
            {
                var archive = AssetSettingEntity.Archive.Create(entity);
                await _table.InsertAsync(archive);

                await _table.ReplaceAsync(AssetSettingEntity.ById.GeneratePartition(), asset, updateEntity =>
                {
                    updateEntity.HotWallet = hotWallet;
                    return(updateEntity);
                });
            }
        }
 public Task UpdatePrice(string orderId, decimal price)
 {
     return(_storage.ReplaceAsync(OffchainOrder.GeneratePartitionKey(), orderId, order =>
     {
         order.Price = price;
         return order;
     }));
 }
 public async Task CompleteTransfer(string transferId, bool?onchain = null, string blockchainHash = null)
 {
     await _storage.ReplaceAsync(OffchainTransferEntity.ByCommon.GeneratePartitionKey(), transferId,
                                 entity =>
     {
         entity.Completed = true;
         if (onchain != null)
         {
             entity.Onchain = onchain.Value;
         }
         if (!string.IsNullOrWhiteSpace(blockchainHash))
         {
             entity.BlockchainHash = blockchainHash;
         }
         return(entity);
     });
 }
예제 #20
0
 public async Task UpdateAsync(AssetHedgeSettings assetHedgeSettings)
 {
     await _storage.ReplaceAsync(GetPartitionKey(), GetRowKey(assetHedgeSettings.AssetId), entity =>
     {
         Mapper.Map(assetHedgeSettings, entity);
         return(entity);
     });
 }
예제 #21
0
        public async Task EditAssetPairAsync(IIntrinsicEventIndicatorsRow row)
        {
            var entity = await _storage.GetDataAsync(IntrinsicEventIndicatorsEntity.GeneratePartitionKeyForRow(), row.RowId);

            entity.PairName = row.PairName;

            await _storage.ReplaceAsync(entity);
        }
        public async Task UpdateAsync(FileInfo fileInfo)
        {
            var entity = new FileInfoEntity(GetPartitionKey(fileInfo.InvoiceId), fileInfo.Id);

            Mapper.Map(fileInfo, entity);

            await _storage.ReplaceAsync(entity);
        }
        public async Task SaveAsync(CashinAggregate aggregate)
        {
            var entity = CashinEntity.FromDomain(aggregate);

            await _storage.ReplaceAsync(entity);

            _chaosKitty.Meow(aggregate.OperationId);
        }
예제 #24
0
        public static Task <T> ReplaceAsync <T>(this INoSQLTableStorage <T> tableStorage, IAzureIndex index, Func <T, T> action) where T : class, ITableEntity, new()
        {
            if (index == null)
            {
                return(Task.FromResult <T>(null));
            }

            return(tableStorage.ReplaceAsync(index.PrimaryPartitionKey, index.PrimaryRowKey, action));
        }
예제 #25
0
 public async Task SetDisabled(string id, bool value)
 {
     await _tableStorage.ReplaceAsync(AssetEntity.GeneratePartitionKey(), AssetEntity.GenerateRowKey(id),
                                      assetEntity =>
     {
         assetEntity.IsDisabled = value;
         return(assetEntity);
     });
 }
        public async Task UpdateAsync(IAssetCategory assetCategory)
        {
            await _assetCategoryTable.ReplaceAsync(GetPartitionKey(), GetRowKey(assetCategory.Id), x =>
            {
                Mapper.Map(assetCategory, x);

                return(x);
            });
        }
        public async Task UpdateAsync(IIssuer issuer)
        {
            await _issuerTable.ReplaceAsync(GetPartitionKey(), GetRowKey(issuer.Id), x =>
            {
                Mapper.Map(issuer, x);

                return(x);
            });
        }
예제 #28
0
        public async Task ReplaceAsync(IMerchant merchant)
        {
            var entity = new MerchantEntity(GetPartitionKey(merchant.Name), GetRowKey(merchant.Name));

            Mapper.Map(merchant, entity);

            entity.ETag = "*";

            await _storage.ReplaceAsync(entity);
        }
예제 #29
0
 public Task SetDialogConditionTypeAsync(string dialogId, DialogConditionType?type)
 {
     return(_tableStorage.ReplaceAsync(ClientDialogEntity.GeneratePartitionKey(),
                                       ClientDialogEntity.GenerateRowKey(dialogId),
                                       entity =>
     {
         entity.ConditionType = type;
         return entity;
     }));
 }
        public Task ChangePasswordAsync(string id, string newPassword)
        {
            string partitionKey = BackOfficeUserEntity.GeneratePartitionKey();
            string rowKey       = BackOfficeUserEntity.GenerateRowKey(id);

            return(_tableStorage.ReplaceAsync(partitionKey, rowKey, itm =>
            {
                itm.SetPassword(newPassword);
                return itm;
            }));
        }