public void ToXml_Includes_DeviceSessionId()
        {
            TransactionRequest request = new TransactionRequest();
            request.DeviceSessionId = "my_dsid";

            Assert.IsTrue(request.ToXml().Contains("my_dsid"));
        }

        public void ToXml_InludesPaymentMethodNonce()
        {
            TransactionRequest request = new TransactionRequest();
            request.PaymentMethodNonce = "1232131232";

            Assert.IsTrue(request.ToXml().Contains("1232131232"));
        }

        public void ToXml_Includes_FraudMerchantId()
        {
            TransactionRequest request = new TransactionRequest();
            request.FraudMerchantId = "my_fmid";

            Assert.IsTrue(request.ToXml().Contains("my_fmid"));
        }

 public deviceTransaction GetDeviceTransaction(TransactionRequest transactionRequest)
 {
     string response = "";
     Dictionary<string, string> responseMap = doRequest(GetURL(), "POST", Serializer<TransactionRequest>.Serialize(transactionRequest).InnerXml);
     responseMap.TryGetValue(MESSAGE, out response);
     return Serializer<deviceTransaction>.Deserialize(response);
 }

        public void Generate_ReturnsTransactionsSettledOnAGivenDay()
        {
            TransactionRequest request = new TransactionRequest
            {
                Amount = 1000M,
                CreditCard = new TransactionCreditCardRequest
                {
                    Number = "4111111111111111",
                    ExpirationDate = "05/2012",
                    CardholderName = "Tom Smith",
                },
                Options = new TransactionOptionsRequest
                {
                    SubmitForSettlement = true
                },
            };

            Transaction transaction = gateway.Transaction.Sale(request).Target;
            Transaction settlementResult = gateway.TestTransaction.Settle(transaction.Id);
            var settlementDate = settlementResult.SettlementBatchId.Substring(0,10);
            transaction = gateway.Transaction.Find(transaction.Id);
            var result = gateway.SettlementBatchSummary.Generate(System.DateTime.Parse(settlementDate));
            var visas = new List<IDictionary<string,string>>();
            foreach (var row in result.Target.Records)
            {
                if (CreditCardCardType.VISA.ToString().Equals(row["card_type"]))
                {
                    visas.Add(row);
                }
            }

            Assert.AreEqual(1, visas.Count);
        }

        private static void Main()
        {
            // Valid transaction
            Console.WriteLine("Begin Transaction...");
            Thread.Sleep(1000);
            var validTransactionRequest = new TransactionRequest
            {
                CardNumber = "123-456-78",
                CardPin = "1234",
                RequestedAmount = 200
            };

            ProcessTransaction(validTransactionRequest);
            Console.WriteLine("End Transaction...\n");
            Thread.Sleep(1000);

            // Invalid card number
            Console.WriteLine("Begin Transaction...");
            Thread.Sleep(1000);
            var invalidCardNumberTransaction = new TransactionRequest
            {
                CardNumber = "111-11-11-111",
                CardPin = "1234",
                RequestedAmount = 200
            };

            ProcessTransaction(invalidCardNumberTransaction);
            Console.WriteLine("End Transaction...\n");
            Thread.Sleep(1000);

            // Invalid card pin
            Console.WriteLine("Begin Transaction...");
            Thread.Sleep(1000);
            var invalidCardPinTransaction = new TransactionRequest
            {
                CardNumber = "111-11-111",
                CardPin = "12345",
                RequestedAmount = 200
            };

            ProcessTransaction(invalidCardPinTransaction);
            Console.WriteLine("End Transaction...\n");
            Thread.Sleep(1000);

            // Invalid money request
            Console.WriteLine("Begin Transaction...");
            Thread.Sleep(1000);
            var invalidMoneyRequestTransaction = new TransactionRequest
            {
                CardNumber = "111-11-111",
                CardPin = "1234",
                RequestedAmount = -200
            };

            ProcessTransaction(invalidMoneyRequestTransaction);
            Console.WriteLine("End Transaction...\n");
            Thread.Sleep(1000);
        }

        public void ToXML_EscapesGeneratedXMLForString()
        {
            TransactionRequest request = new TransactionRequest
            {
                OrderId = "<>&\"'"
            };

            TestHelper.AssertIncludes("<order-id>&lt;&gt;&amp;&quot;&#39;</order-id>", request.ToXml());
        }

        public void HashIsComputedCorrectly0()
        {
            var request = new TransactionRequest();
            request.Add("KEY1", "VALUE1");
            var client = GetClient();
            client.SetHash(request);

            Assert.AreEqual("05b2372310c2897729f9c185517a25168e6891f2c7749329255f494e1483f181", request["HASH"]);
        }

        public void HashIsComputedCorrectly1()
        {
            var request = new TransactionRequest();
            request.Add("ORDERID", "VALUE1");
            request.Add("DATE", "VALUE2");
            var client = GetClient();
            client.SetHash(request);

            Assert.AreEqual("b7c312f5d79aebc472d91b7395ba855b00bcfee5e15b13a01af85a9f64737a89", request["HASH"]);
        }

        public void HashIsComputedCorrectly0_Verify()
        {
            var hash = "05b2372310c2897729f9c185517a25168e6891f2c7749329255f494e1483f181";
            var request = new TransactionRequest();
            request.Add("KEY1", "VALUE1");
            var client = GetClient();
            var result = client.VerifyParameters(request, GetClientConfiguration().ApiKey, hash);

            Assert.IsTrue(result);
        }

 public void TestService()
 {
     request = new TransactionRequest();
     request.TokenUniqueId = "DWSPMC00000000010906a349d9ca4eb1a4d53e3c90a11d9c";
     request.AuditInfo.UserId = "testUser";
     request.AuditInfo.UserName = "Test User";
     request.AuditInfo.Organization = "Test Org";
     response = service.GetDeviceTransaction(request);
     Assert.IsNotNull(response.Transactions);
 }

        public void ToXml_Includes_DeviceData()
        {
            TransactionRequest request = new TransactionRequest();
            request.DeviceData = "{\"device_session_id\":\"my_dsid\", \"fraud_merchant_id\":\"my_fmid\"}";

            Assert.IsTrue(request.ToXml().Contains("device-data"));
            Assert.IsTrue(request.ToXml().Contains("device_session_id"));
            Assert.IsTrue(request.ToXml().Contains("my_dsid"));
            Assert.IsTrue(request.ToXml().Contains("fraud_merchant_id"));
            Assert.IsTrue(request.ToXml().Contains("my_fmid"));
        }

            public void OnPaymentFinished(string orderId, TransactionRequest originalRequest, IDictionary<String, String> result, ApiPaymentCompletedStatus status)
            {
                //handle payment finished
                string textResult = "Order ID: " + orderId + "\n" + "Status: " + status + "\n";

                foreach(KeyValuePair<string, string> entry in result)
                {
                    textResult = textResult + entry.Key + ": " + entry.Value + "\n";
                }

                this.paymentDataView.Text = textResult;
            }

        public void ToXML_EscapesGeneratedXMLForNestedSearchCriteria()
        {
            TransactionRequest request = new TransactionRequest
            {
                Customer = new CustomerRequest
                {
                    FirstName = "<John>"
                }
            };

            TestHelper.AssertIncludes("<first-name>&lt;John&gt;</first-name>", request.ToXml());
        }

 private static void ProcessTransaction(TransactionRequest transactionRequest)
 {
     try
     {
         AtmDbData.WithdrawMoney(transactionRequest);
         Console.WriteLine("\tRequested transaction was successful!");
     }
     catch (Exception)
     {
         Console.WriteLine("\tRequested transaction was not successful!");
     }
 }

        bool ITransactionProcessor.AddRequest(int tickerIndex, double quantity)
        {
            if (!quoteContext.GetTickerDescription(tickerIndex).CanBeBought) return false;

            var req = new TransactionRequest(tickerIndex, quantity < 0 ? 0 : quantity, delay.Value);
            if (delay.Value == 0)
                return ProcessTransactionRequest(req);
            else
                transactionRequests.Add(req);

            return true;
        }

 public void Sign_Transaction()
 {
     //Just checking for no errors here- not yet sure how we verify this,
     //unless we call into another way of signing and verify the two match
     TransactionRequest t = new TransactionRequest()
     {
         AmountInCents = 124,
         CurrencyCode = Currency.GBP,
         Description = "test description"
     };
     RecurlyJs signer = new RecurlyJs("testkey","testapi");
     var signedString = signer.SignString(t.ToSignableString());
 }

        public void WithdrawMoney(TransactionRequest transactionRequest)
        {
            using (var transaction = new AtmDbContext().Database.BeginTransaction())
            {
                try
                {
                    if (!this.validator.IsValidCardNumber(transactionRequest.CardNumber))
                    {
                        throw new ArgumentException("Invalid card number. Current transaction is aborted!");
                    }

                    if (!this.validator.IsValidCardPin(transactionRequest.CardPin))
                    {
                        throw new ArgumentException("Invalid Card PIN Code. Current transaction is aborted!");
                    }

                    var cardAccount = this.atmDbContext.CardAccounts
                        .FirstOrDefault(ca => ca.CardNumber == transactionRequest.CardNumber &&
                                              ca.CardPin == transactionRequest.CardPin);
                    if (cardAccount == null)
                    {
                        throw new ArgumentException(
                            "There is no Card account with the given Card number. Current transaction is aborted!");
                    }

                    if (!this.validator.IsPinCodeMatches(transactionRequest.CardPin, cardAccount.CardPin))
                    {
                        throw new ArgumentException(
                            "Chosen Card PIN Code does not matches the actual PIN Code of the card account. Current transaction is aborted!");
                    }

                    if (
                        !this.validator.IsPermittedWithdrawalAmount(transactionRequest.RequestedAmount,
                            cardAccount.CardCash))
                    {
                        throw new ArgumentException(
                            "Invalid withdrawal money amount to retrieve. Current transaction is aborted!");
                    }

                    cardAccount.CardCash -= transactionRequest.RequestedAmount;

                    transaction.Commit();
                    this.atmDbContext.SaveChanges();
                }
                catch (Exception ex)
                {
                    transaction.Rollback();
                    Console.WriteLine("\t" + ex.Message);
                }
            }
        }

        /// <summary>
        /// Creates the authorization/payment parameters. You have to call SetPayWithForm or SetPayWithAlias after.
        /// </summary>
        /// <param name="uniqueOrderId">The unique order unique identifier (you have to create it).</param>
        /// <param name="userId">The user unique identifier.</param>
        /// <param name="userEmail">The user email.</param>
        /// <param name="description">The description of the payment.</param>
        /// <param name="amountInEuro">The amount information euro (not in cents).</param>
        /// <param name="createAlias">if set to <c>true</c> [create alias] (to do oneclick later).</param>
        /// <param name="displayCreateAlias">if set to <c>true</c> the payment form will ask whether to save the card information.</param>
        /// <param name="authorizationInsteadOfPayment">if set to <c>true</c> [authorization instead of payment]. Call Capture to complete the transaction.</param>
        /// <param name="language">The language.</param>
        /// <returns></returns>
        public TransactionRequest CreateAuthorizationParameters(
            string uniqueOrderId,
            string userId,
            string userEmail,
            string description,
            decimal amountInEuro,
            bool createAlias = false,
            bool displayCreateAlias = false,
            bool authorizationInsteadOfPayment = false,
            Be2BillLanguage language = Be2BillLanguage.EN)
        {
            // http://developer.be2bill.com/platform

            var collection = new TransactionRequest();

            if (authorizationInsteadOfPayment)
            {
                collection.Add(Names.Params.OperationType, Names.Params.OperationTypeAuthorization);
            }
            else
            {
                collection.Add(Names.Params.OperationType, Names.Params.OperationTypePayment);
            }

            collection.Add(Names.Params.Description, description);
            collection.Add(Names.Params.OrderId, uniqueOrderId); // be2bill seems to accept only 1 tentative per ORDERID
            collection.Add(Names.Params.Amount, Math.Round(amountInEuro * 100).ToString());
            collection.Add(Names.Params.Version, Names.ApiVersion);
            collection.Add(Names.Params.ClientIdent, userId);
            collection.Add(Names.Params.Language, language.ToString());

            if (createAlias)
            {
                collection.Add(Names.Params.CreateAlias, Names.Params.Yes); // allow one-click for later transactions (force)
            }

            if (displayCreateAlias)
            {
                collection.Add(Names.Params.DisplayCreateAlias, Names.Params.Yes); // allow one-click for later transactions (ask user)
            }

            collection.Add(Names.Params.Identifier, configuration.ApiIdentifier);

            if (userEmail != null)
            {
                collection.Add(Names.Params.ClientEmail, userEmail);
            }

            return collection;
        }

 public IList<Transaction> Get(TransactionRequest request)
 {
     var transactions = new List<Transaction>();
     for (int i = 1; i < 30; i++)
     {
         transactions.Add(new Transaction()
         {
             Date = DateTime.Now.AddDays(i),
             Details = "Transaction " + i,
             CreditAmount = 10 + i,
             DebitAmount = 10 - i
         });
     }
     return transactions;
 }