public async Task <EnrolledBalance> TryGetAsync(DepositWalletKey key)
        {
            var partitionKey = EnrolledBalanceEntity.GetPartitionKey(key);
            var rowKey       = EnrolledBalanceEntity.GetRowKey(key);

            var entity = await _storage.GetDataAsync(partitionKey, rowKey);

            return(entity != null
                ? EnrolledBalance.Create(key, entity.Balance, entity.Block)
                : null);
        }
Exemplo n.º 2
0
        private static EnrolledBalance MapFromEntity(EnrolledBalanceEntity entity)
        {
            if (entity == null)
            {
                return(null);
            }

            BigInteger.TryParse(entity.Balance, out var balance);
            return(EnrolledBalance.Create(
                       new DepositWalletKey(entity.BlockchainAssetId, entity.BlockchianId, entity.OriginalWalletAddress),
                       balance,
                       entity.BlockNumber));
        }
        public async Task <EnrolledBalance> TryGetAsync(DepositWalletKey key)
        {
            if (!_memCache.TryGetValue(key, out EnrolledBalance value))
            {
                value = await _enrolledBalanceRepository.TryGetAsync(key);

                using (var entry = _memCache.CreateEntry(key))
                {
                    entry.Value = EnrolledBalance.Create(key, value?.Balance ?? 0, value?.Block ?? 0);
                }
            }

            return(value);
        }
        public async Task <IEnumerable <EnrolledBalance> > GetAsync(IEnumerable <DepositWalletKey> keys)
        {
            var entityKeys = keys.Select(key => new Tuple <string, string>
                                         (
                                             EnrolledBalanceEntity.GetPartitionKey(key),
                                             EnrolledBalanceEntity.GetRowKey(key)
                                         ));

            return((await _storage.GetDataAsync(entityKeys))
                   .Select(e => EnrolledBalance.Create
                           (
                               new DepositWalletKey(e.BlockchainAssetId, e.BlockchainType, e.DepositWalletAddress),
                               e.Balance,
                               e.Block
                           )));
        }
        public async Task ResetBalanceAsync(DepositWalletKey key, long transactionBlock)
        {
            await _enrolledBalanceRepository.ResetBalanceAsync(key, transactionBlock);

            if (_memCache.TryGetValue(key, out EnrolledBalance value))
            {
                value.Balance = 0;
                value.Block   = transactionBlock;
            }
            else
            {
                using (var entry = _memCache.CreateEntry(key))
                {
                    entry.Value = EnrolledBalance.Create(key, 0, value.Block);
                }
            }
        }
        public async Task SetBalanceAsync(DepositWalletKey key, BigInteger balance, long balanceBlock)
        {
            await _enrolledBalanceRepository.SetBalanceAsync(key, balance, balanceBlock);

            if (_memCache.TryGetValue(key, out EnrolledBalance value))
            {
                value.Block   = balanceBlock;
                value.Balance = balance;
            }
            else
            {
                using (var entry = _memCache.CreateEntry(key))
                {
                    entry.Value = EnrolledBalance.Create(key, balance, balanceBlock);
                }
            }
        }