public static bool Charge(Customer customer, CreditCard creditcard, decimal amount)
        {
            var myCharge = new StripeChargeCreateOptions();

            // always set these properties
            myCharge.Amount = (int)amount*100;
            myCharge.Currency = "usd";

            // setting up the card
            myCharge.Source = new StripeSourceOptions()
            {
                Object = "card",
                Number = creditcard.creditCardNumber,
                ExpirationMonth = creditcard.expiryDateMonth,
                ExpirationYear = creditcard.expiryDateYear,
                Cvc = creditcard.securityCode                          // optional
            };
            
            var chargeService = new StripeChargeService(StripeApiKey);
            StripeCharge apiResponse = chargeService.Create(myCharge);

            if(apiResponse.Paid == false)
            {
                throw new Exception(apiResponse.FailureMessage);
            }


           
            return apiResponse.Paid;
          


        }

 ///<summary>Inserts one CreditCard into the database.  Returns the new priKey.</summary>
 internal static long Insert(CreditCard creditCard)
 {
     if(DataConnection.DBtype==DatabaseType.Oracle) {
         creditCard.CreditCardNum=DbHelper.GetNextOracleKey("creditcard","CreditCardNum");
         int loopcount=0;
         while(loopcount<100){
             try {
                 return Insert(creditCard,true);
             }
             catch(Oracle.DataAccess.Client.OracleException ex){
                 if(ex.Number==1 && ex.Message.ToLower().Contains("unique constraint") && ex.Message.ToLower().Contains("violated")){
                     creditCard.CreditCardNum++;
                     loopcount++;
                 }
                 else{
                     throw ex;
                 }
             }
         }
         throw new ApplicationException("Insert failed.  Could not generate primary key.");
     }
     else {
         return Insert(creditCard,false);
     }
 }

 public Orders()
 {
     _creditCard = new CreditCard();
     _orderDetails = new OrderDetails();
     _endUser = new EndUser();
     _shippingAddress = new Address();
 }

        public void InsertContactTest()
        {
            var dl = new DriversLicense
                                    {
                                        LicenseNumber = "12345678",
                                        DateOfBirth = DateTime.Today,
                                        Expiry = DateTime.Today
                                    };

            var cc = new CreditCard
                                {
                                    CardNumber = "123123131312",
                                    NameOnCard = "J Bloggs",
                                    ExpiryDate = "02/12",
                                    CreditCardType = CreditCardType.Visa
                                };

            var contact = new Contact
            {
                Name = "Joe Bloggs",
                Email = "[email protected]",
                DriversLicense = dl,
                CreditCard = cc,
            };

            contactRepository.InsertContact(contact);
            Assert.IsNotNull(contact.Id);
        }

        public static bool Charge(Customer cus, CreditCard cc, decimal amount) //PRD)
        {
            var chargeDetails = new StripeChargeCreateOptions();
            chargeDetails.Amount = (int)amount * 100;
            chargeDetails.Currency = "usd";

            chargeDetails.Source = new StripeSourceOptions
            {
                Object = "card",
                Number = cc.CardNum,
                ExpirationMonth = cc.Expiration.Substring(0, 2),
                ExpirationYear = cc.Expiration.Substring(3, 2),
                Cvc = cc.CVC
            };

            var chargeService = new StripeChargeService(APIKey);
            var response = chargeService.Create(chargeDetails);

            if (response.Paid == false)
            {
                throw new Exception(response.FailureMessage);
            }

            return response.Paid;

        }

    protected void lbBasicAuth_Click(object sender, EventArgs e)
    {
        string merchantId = ConfigurationManager.AppSettings["MerchantID"];
        string account = ConfigurationManager.AppSettings["Account"];
        string sharedSecret = ConfigurationManager.AppSettings["SharedSecret"];

        Merchant merchant = new Merchant(merchantId, account, sharedSecret);
        Order order = new Order("GBP", 999);
        //working
        CreditCard card = new CreditCard("MC", "5425232820001308", "0118", "Phil McCracken", "123", 1);
        //invalid
        //CreditCard card = new CreditCard("MC", "1234123412341234", "0118", "Phil McCracken", "123", 1);
        Address address = new Address("", "", "", "", "", "", "", "");
        PhoneNumbers numbers = new PhoneNumbers("", "", "", "");
        Payer payer = new Payer("Business", "test", "", "Phil", "McCracken", "", address, numbers, "", new ArrayList());

        string timestamp = Common.GenerateTimestamp();

        string autoSettle = "1";

        RealAuthTransactionResponse resp = RealAuthorisation.Auth(merchant, order, card, autoSettle, timestamp);

        lblErrorCode.Text = resp.ResultCode.ToString();
        lblResult.Text = resp.ResultMessage;
    }

 /// <summary>
 /// Construtor da classe <see cref="TransactionRequest"/>.
 /// </summary>
 /// <param name="sellerMail">E-mail da loja cadastrada no Pagamento Digital.</param>
 /// <param name="ipSeller">Endereço de IP da loja.</param>
 /// <param name="orderId">Código do pedido atribuído pela loja.</param>
 /// <param name="buyer">Objeto <see cref="Customer"/>.</param>
 /// <param name="free">Campo de Livre Digitação. Pode ser utilizado para algum parâmetro adicional de identificação da venda.</param>
 /// <param name="freight">Valor do frete.</param>
 /// <param name="freightType">Tipo do frete.</param>
 /// <param name="discount">Valor total do desconto atribuído pela loja.</param>
 /// <param name="addition">Valor total do acréscimo feito pela loja.</param>
 /// <param name="paymentMethod">Objeto <see cref="PaymentMethod"/>.</param>
 /// <param name="urlReturn">URL que direciona o usuário para a loja.</param>
 /// <param name="urlWarning">URL que a loja irá receber as informações de alteração de status da transação.</param>
 /// <param name="products">Lista de produtos.</param>
 /// <param name="installments">Quantidade de Parcelas em que a compra será processada.</param>
 /// <param name="creditCard">Objeto <see cref="CreditCard"/>.</param>
 /// <param name="currency">Moeda utilizada para a transação.</param>
 /// <param name="acceptedContract">Loja informa se o comprador aceitou os termos do contrato.</param>
 /// <param name="viewedContract">Loja informa se o comprador visualizou os termos do contrato.</param>
 /// <param name="campaignId">Identificador da campanha da loja no Pagamento Digital.</param>
 /// <param name="dependentTransactions">Lista de transações dependentes.</param>
 public TransactionRequest(string sellerMail, string ipSeller, string orderId, Customer buyer, string free,
     decimal freight, string freightType, decimal discount, decimal addition,
     PaymentMethod paymentMethod, string urlReturn, string urlWarning, List<Product> products,
     int installments, CreditCard creditCard, string currency, bool acceptedContract,
     bool viewedContract, int campaignId, List<DependentTransaction> dependentTransactions)
 {
     this.SellerMail = sellerMail;
     this.IpSeller = ipSeller;
     this.OrderId = orderId;
     this.Buyer = buyer;
     this.Free = free;
     this.Freight = freight;
     this.FreightType = freightType;
     this.Discount = discount;
     this.Addition = addition;
     this.PaymentMethod = paymentMethod;
     this.UrlReturn = urlReturn;
     this.UrlNotification = urlWarning;
     this.Products = products;
     this.Installments = installments;
     this.CreditCard = creditCard;
     this.Currency = currency;
     this.AcceptedContract = acceptedContract;
     this.ViewedContract = viewedContract;
     this.CampaignId = campaignId;
     this.DependentTransactions = dependentTransactions;
 }

        public static bool Charge(Customer customer, CreditCard creditCard, decimal amount)
        {
            var chargeDetails = new StripeChargeCreateOptions();
            chargeDetails.Amount = (int)(amount * 100);
            chargeDetails.Currency = "usd";

            chargeDetails.Source = new StripeSourceOptions
            {
                Object = "card",
                Number = creditCard.CardNumber,
                ExpirationMonth = creditCard.ExpirationDate.Month.ToString(),
                ExpirationYear = creditCard.ExpirationDate.Year.ToString(),
                Cvc = creditCard.Cvc
            };

            var chargeService = new StripeChargeService(StripeApiKey);
            var response = chargeService.Create(chargeDetails);

            if (response.Paid == false)
            {
                throw new Exception(response.FailureMessage);
            }

            return response.Paid;

        }

        /// <summary>
        /// Subscribes the user to a Stripe plan. If the user doesn't exist in Stripe, is created
        /// </summary>
        /// <param name="user">Application User</param>
        /// <param name="planId">Plan Id to subscribe the user to</param>
        /// <param name="taxPercent">The tax percent.</param>
        /// <param name="creditCard">The credit card.</param>
        /// <returns>
        /// Subscription
        /// </returns>
        public async Task<Subscription> SubscribeUserAsync
            (SaasEcomUser user, string planId, decimal taxPercent = 0, CreditCard creditCard = null)
        {
            Subscription subscription;
            
            // If the user isn't created in Stripe 
            if (string.IsNullOrEmpty(user.StripeCustomerId))
            {
                // Save the subscription in the DB
                subscription = await _subscriptionDataService.SubscribeUserAsync(user, planId, trialPeriodInDays: null, taxPercent: taxPercent);

                // Create a new customer in Stripe and subscribe him to the plan
                var cardToken = creditCard == null ? null : creditCard.StripeToken;
                var stripeUser = (StripeCustomer) await _customerProvider.CreateCustomerAsync(user, planId, null, cardToken);
                user.StripeCustomerId = stripeUser.Id; // Add stripe user Id to the user

                // Save Stripe Subscription Id in the DB
                subscription.StripeId = GetStripeSubscriptionIdForNewCustomer(stripeUser);
                await _subscriptionDataService.UpdateSubscriptionAsync(subscription);
            }
            else // Create new subscription in Stripe and DB
            {
                subscription = await this.SubscribeUserAsync(user, planId, creditCard, 0, taxPercent: taxPercent);
            }

            // Update tax percent on stripe
            if (taxPercent > 0)
            {
                await this.UpdateSubscriptionTax(user, subscription.StripeId, taxPercent);
            }

            return subscription;
        }

 public PaymentMethod(CreditCard creditCard,
     PurchaseType purchaseType,
     int installments = 1)
 {
     CreditCard = creditCard;
     PurchaseType = purchaseType;
     Installments = installments;
 }

 public void Insert(CreditCard model)
 {
     using (_db = new MyCoolDbEntities())
     {
         _db.CreditCards.AddObject(model);
         _db.SaveChanges();
         
     }
 }

 public void Delete(CreditCard model)
 {
     using (_db = new MyCoolDbEntities())
     {
         var entity = _db.CreditCards.Where(c => c.Id == model.Id).SingleOrDefault();
         _db.CreditCards.DeleteObject(entity);
         _db.SaveChanges();
     }
 }

        public CardTokenTests()
        {
            _card = new CreditCard {
                Number = "4111111111111111",
                ExpMonth = 3,
                ExpYear = 2015
            };

            _client = new StripeClient(Constants.ApiKey);
        }

        public CustomerTests()
        {
            _card = new CreditCard {
                Number = "4242424242424242",
                ExpMonth = 3,
                ExpYear = 2015
            };

            _client = new StripeClient(Constants.ApiKey);
        }

        public void Setup()
        {
            _card = new CreditCard {
                Number = "4111111111111111",
                ExpMonth = 3,
                ExpYear = 2015
            };

            _client = new StripeClient(Constants.ApiKey);
        }

 public void Update(CreditCard entity)
 {
     using (_db = new MyCoolDbEntities())
     {
         _db.CreditCards.Attach(entity);
         _db.ObjectStateManager.ChangeObjectState(entity, System.Data.EntityState.Modified);
         _db.CreditCards.ApplyCurrentValues(entity);
         _db.SaveChanges();
     }
 }

        /// <summary>
        /// Adds the credit card asynchronous.
        /// </summary>
        /// <param name="user">The user.</param>
        /// <param name="card">The card.</param>
        /// <returns></returns>
        public async Task AddAsync(SaasEcomUser user, CreditCard card)
        {
            // Save to Stripe
            var stripeCustomerId = user.StripeCustomerId;
            AddCardToStripe(card, stripeCustomerId);

            // Save to storage
            card.SaasEcomUserId = user.Id;
            await _cardDataService.AddAsync(card);
        }

        public ChargeTests()
        {
            _card = new CreditCard {
                Number = "4242 4242 4242 4242",
                ExpMonth = DateTime.Now.Month,
                ExpYear = DateTime.Now.AddYears(1).Year
            };

            _client = new StripeClient(Constants.ApiKey);
            _customer = _client.CreateCustomer(_card);
        }

        public CardTokenTests()
        {
            _card = new CreditCard
            {
                Number = "4242424242424242",
                ExpMonth = 3,
                ExpYear = (DateTime.Now.Year + 2)
            };

            _client = new StripeClient(Constants.ApiKey);
        }

        public ChargeTests()
        {
            _card = new CreditCard {
                Number = "4242 4242 4242 4242",
                ExpMonth = 3,
                ExpYear = 2015
            };

            _client = new StripeClient(Constants.ApiKey);
            _customer = _client.CreateCustomer(_card);
        }