public void CompleteOnlineTest()
        {
            Transaction transaction = this.TransactionService.Create(this.SpaceId, this.GetTransactionPayload());

            for (var i = 1; i <= 30; i++)
            {
                Console.WriteLine(transaction.State);

                if (TransactionState.AUTHORIZED == transaction.State)
                {
                    break;
                }
                System.Threading.Thread.Sleep(i * 30);
                transaction = this.TransactionService.Read(this.SpaceId, transaction.Id);
            }

            if (TransactionState.AUTHORIZED == transaction.State)
            {
                transaction = this.TransactionService.ProcessWithoutUserInteraction(this.SpaceId, transaction.Id);
                TransactionCompletion        transactionCompletion       = this.TransactionCompletionService.CompleteOnline(this.SpaceId, transaction.Id);
                TransactionCompletionState[] TransactionCompletionStates =
                {
                    TransactionCompletionState.SUCCESSFUL,
                    TransactionCompletionState.PENDING
                };
                Assert.AreEqual(true, Array.Exists(TransactionCompletionStates, element => element == transactionCompletion.State));
            }
            else
            {
                Console.WriteLine("Transaction is not in state AUTHORIZED");
                Assert.AreEqual(true, TransactionState.AUTHORIZED != transaction.State);
            }
        }
Esempio n. 2
0
        public static float ToPercentValue(this TransactionCompletion completion)
        {
            switch (completion)
            {
            case TransactionCompletion.None: return(0f);

            case TransactionCompletion.Requested: return(0.001f);

            case TransactionCompletion.Promised: return(0.25f);

            case TransactionCompletion.Executed: return(0.50f);

            case TransactionCompletion.Stated: return(0.75f);

            case TransactionCompletion.Accepted: return(1f);

            case TransactionCompletion.Declined: return(0.10f);

            case TransactionCompletion.Quitted: return(0.10f);

            case TransactionCompletion.Rejected: return(0.50f);

            case TransactionCompletion.Stopped: return(0.50f);

            default:
                throw new ArgumentOutOfRangeException();
            }
        }
Esempio n. 3
0
        public static string AsAbbreviation(this TransactionCompletion completion)
        {
            switch (completion)
            {
            case TransactionCompletion.None: return("xx");

            case TransactionCompletion.Requested: return("Rq");

            case TransactionCompletion.Declined: return("Dc");

            case TransactionCompletion.Quitted: return("Qt");

            case TransactionCompletion.Promised: return("Pm");

            case TransactionCompletion.Executed: return("Ex");

            case TransactionCompletion.Stated: return("St");

            case TransactionCompletion.Rejected: return("Rj");

            case TransactionCompletion.Stopped: return("St");

            case TransactionCompletion.Accepted: return("Ac");

            default:
                throw new ArgumentOutOfRangeException();
            }
        }
Esempio n. 4
0
        public void RefundTest()
        {
            Transaction transaction = this.TransactionService.ProcessWithoutUserInteraction(this.SpaceId, this.Transaction.Id);

            Console.WriteLine(transaction.Id);
            TransactionState[] TransactionStates =
            {
                TransactionState.FAILED,
                TransactionState.FULFILL
            };
            for (var i = 1; i <= 5; i++)
            {
                Console.WriteLine(transaction.State);

                if (Array.Exists(TransactionStates, element => element == transaction.State))
                {
                    break;
                }
                System.Threading.Thread.Sleep(i * 30);
                transaction = this.TransactionService.Read(this.SpaceId, transaction.Id);
            }

            if (transaction.State == TransactionState.FULFILL)
            {
                TransactionCompletion transactionCompletion = this.TransactionCompletionService.CompleteOffline(this.SpaceId, transaction.Id);
                Assert.AreEqual(transactionCompletion.State, TransactionCompletionState.SUCCESSFUL);
                transaction = this.TransactionService.Read(this.SpaceId, transactionCompletion.LinkedTransaction);  // fetch the latest transaction data
                RefundCreate refundPayload = this.GetRefundPayload(transaction);
                Refund       refund        = this.RefundService.Refund(this.SpaceId, refundPayload);
                Assert.AreEqual(refund.State, RefundState.SUCCESSFUL);
            }
        }
 public TransactionEvent(int transactionInstanceId, int transactionKindId, int raisedByActorId, DateTime created, TransactionCompletion completion)
 {
     Id = Interlocked.Increment(ref nextId);
     TransactionInstanceId = transactionInstanceId;
     TransactionKindId     = transactionKindId;
     RaisedByActorId       = raisedByActorId;
     Created    = created;
     Completion = completion;
 }
Esempio n. 6
0
        public static float RemainingAsWidth(this TransactionCompletion completion, float widthRequest)
        {
            var total = 0f;

            for (var i = (int)completion + 1; i <= 5; i++)
            {
                total += 0.25f * widthRequest;
            }

            return(total);
        }
Esempio n. 7
0
 public void AddTransactionLink(TransactionKind sourceTransaction, TransactionKind destinationTransaction, TransactionCompletion sourceCompletion, TransactionCompletion destinationCompletion, TransactionLinkType linkType)
 {
     links.Add(new TransactionLink
     {
         SourceTransactionKindId      = sourceTransaction.Id,
         DestinationTransactionKindId = destinationTransaction.Id,
         SourceCompletion             = sourceCompletion,
         DestinationCompletion        = destinationCompletion,
         Type = linkType
     });
 }
        private static float GetMaximumDependendChildWidth(TransactionBoxControl parent, TransactionCompletion offset)
        {
            var leftSpace = parent.GetCompletionOffset(offset);

            return((float)(parent.WidthRequest - leftSpace));
        }
 private TransactionLinkBuilder NewLink(TransactionCompletion sourceCompletion, TransactionCompletion targetCompletion,
                                        TransactionBoxControl sourceControl, TransactionBoxControl targetControl) => TransactionLinkBuilder.New(sourceCompletion, targetCompletion, sourceControl, targetControl);
Esempio n. 10
0
 public TransactionLinkBuilder SetOffsetCompletion(TransactionCompletion completion)
 {
     link.OffsetCompletion = completion;
     return(this);
 }
Esempio n. 11
0
 public static TransactionLinkBuilder New(TransactionCompletion sourceCompletion, TransactionCompletion targetCompletion,
                                          TransactionBoxControl sourceControl, TransactionBoxControl targetControl) => new TransactionLinkBuilder(sourceCompletion, targetCompletion, sourceControl, targetControl);
Esempio n. 12
0
 private TransactionLinkBuilder(TransactionCompletion sourceCompletion, TransactionCompletion targetCompletion,
                                TransactionBoxControl sourceControl, TransactionBoxControl targetControl)
 {
     link = new TransactionLinkControl(sourceCompletion, targetCompletion, sourceControl, targetControl);
 }