public BroadcastedSingleTransaction(BroadcastedSingleTransactionResponse contract, int assetAccuracy, Guid expectedOperationId) :
            base(contract, assetAccuracy, expectedOperationId)
        {
            if (!string.IsNullOrEmpty(contract.Amount))
            {
                try
                {
                    Amount = Conversions.CoinsFromContract(contract.Amount, assetAccuracy);

                    if (Amount <= 0)
                    {
                        throw new ResultValidationException("Amount should be positive number", contract.Amount);
                    }
                }
                catch (ConversionException ex)
                {
                    throw new ResultValidationException("Failed to parse amount", contract.Amount, ex);
                }
            }
        }
        public BroadcastedSingleTransaction(BroadcastedSingleTransactionResponse contract, int assetAccuracy, Guid expectedOperationId) :
            base(contract, assetAccuracy, expectedOperationId)
        {
            var isAmountValid = false;

            if (!string.IsNullOrEmpty(contract.Amount))
            {
                try
                {
                    Amount = Conversions.CoinsFromContract(contract.Amount, assetAccuracy);

                    if (contract.State == BroadcastedTransactionState.Completed && Amount > 0 ||
                        (contract.State == BroadcastedTransactionState.Failed ||
                         contract.State == BroadcastedTransactionState.InProgress
                        ) && Amount >= 0
                        )
                    {
                        isAmountValid = true;
                    }
                }
                catch (ConversionException ex)
                {
                    throw new ResultValidationException("Failed to parse amount", contract.Amount, ex);
                }
            }
            else
            {
                if (contract.State == BroadcastedTransactionState.Failed ||
                    contract.State == BroadcastedTransactionState.InProgress)
                {
                    isAmountValid = true;
                }
            }


            if (!isAmountValid)
            {
                throw new ResultValidationException("Amount should be positive number", contract.Amount);
            }
        }
コード例 #3
0
        public async Task <ActionResult <BroadcastedSingleTransactionResponse> > GetSingleTransactionState(
            TransactionRequest request)
        {
            var txState = await _transactionService.TryGetTransactionAsync(request.TransactionId);

            if (txState != null)
            {
                var response = new BroadcastedSingleTransactionResponse
                {
                    Amount      = txState.Amount.ToString(),
                    Block       = txState.BlockNumber.HasValue ? (long)txState.BlockNumber.Value : 0,
                    Fee         = (txState.GasAmount * txState.GasPrice).ToString(),
                    Hash        = txState.Hash,
                    OperationId = txState.TransactionId
                };

                switch (txState.State)
                {
                case TransactionState.Built:
                    return(NoContent());

                case TransactionState.InProgress:
                    response.State     = BroadcastedTransactionState.InProgress;
                    response.Timestamp = txState.BuiltOn;
                    break;

                case TransactionState.Completed:
                    response.State = BroadcastedTransactionState.Completed;
                    // ReSharper disable once PossibleInvalidOperationException
                    response.Timestamp = txState.CompletedOn.Value;
                    break;

                case TransactionState.Failed:
                    response.State = BroadcastedTransactionState.Failed;
                    // ReSharper disable once PossibleInvalidOperationException
                    response.Timestamp = txState.CompletedOn.Value;
                    break;

                case TransactionState.Deleted:
                    return(NoContent());

                default:
                    throw new ArgumentOutOfRangeException();
                }

                if (txState.BlockNumber.HasValue)
                {
                    response.Block = (long)txState.BlockNumber.Value;
                }

                if (!string.IsNullOrEmpty(txState.Error))
                {
                    response.Error     = txState.Error;
                    response.ErrorCode = BlockchainErrorCode.AmountIsTooSmall;
                    // TODO: Replace with correct response, as soon, as it will be implemented in common part
                    //response.ErrorCode = BlockchainErrorCode.Unknown;
                }

                return(response);
            }
            else
            {
                return(NoContent());
            }
        }
コード例 #4
0
        public async Task <ActionResult <BroadcastedSingleTransactionResponse> > GetSingleTransactionState(
            TransactionRequest request)
        {
            var txState = await _transactionService.TryGetTransactionAsync(request.TransactionId);

            if (txState != null)
            {
                var response = new BroadcastedSingleTransactionResponse
                {
                    Amount      = txState.Amount.ToString(),
                    Block       = txState.BlockNumber.HasValue ? (long)txState.BlockNumber.Value : 0,
                    Fee         = (txState.GasAmount * txState.GasPrice).ToString(),
                    Hash        = txState.Hash,
                    OperationId = txState.TransactionId
                };

                if (txState.State == TransactionState.Built || txState.State == TransactionState.Deleted)
                {
                    return(NoContent());
                }

                if (txState.State == TransactionState.InProgress || !txState.IsConfirmed)
                {
                    response.State     = BroadcastedTransactionState.InProgress;
                    response.Timestamp = txState.BuiltOn;

                    return(response);
                }

                // ReSharper disable once SwitchStatementMissingSomeCases
                switch (txState.State)
                {
                case TransactionState.Completed:
                    response.State = BroadcastedTransactionState.Completed;
                    break;

                case TransactionState.Failed:
                    response.State = BroadcastedTransactionState.Failed;
                    break;
                }

                if (txState.CompletedOn.HasValue)
                {
                    response.Timestamp = txState.CompletedOn.Value;
                }

                if (txState.BlockNumber.HasValue)
                {
                    response.Block = (long)txState.BlockNumber.Value;
                }

                if (!string.IsNullOrEmpty(txState.Error))
                {
                    response.Error     = txState.Error;
                    response.ErrorCode = BlockchainErrorCode.Unknown;
                }

                return(response);
            }
            else
            {
                return(NoContent());
            }
        }