public void AddPaymentMethods(PaymentMethod method, SelectList list)
        {
            if (PaymentMethodsList == null)
                InitPaymentMethodsList(null);

            PaymentMethodsList.ItemsList.Add(method, list);
        }

        public void GivenTheFollowingTransaction(string category, string paymentMethod, Table data)
        {
            _paymentMethodService = new PaymentMethodService(new PaymentMethodRepository(context));

            switch (_transactionType)
            {
                case TransactionTypes.Income:
                    _transaction = data.CreateInstance<Income>();
                    _transactionService = new IncomeService(new IncomeRepository(context));
                    _categoryService = new IncomeCategoryService(new IncomeCategoryRepository(context));
                    break;
                case TransactionTypes.Expense:
                    _transaction = data.CreateInstance<Expense>();
                    _transactionService = new ExpenseService(new ExpenseRepository(context));
                    _categoryService = new ExpenseCategoryService(new ExpenseCategoryRepository(context));
                    break;
            }

            if (!string.IsNullOrWhiteSpace(paymentMethod))
            {
                _paymentMethod = new PaymentMethod(0, paymentMethod);
                _transaction.Method = _paymentMethod;
            }

            if (!string.IsNullOrWhiteSpace(category))
            {
                _category = new DataClasses.Category(0, category);
                _transaction.Category = _category;
            }

            if (_transaction.Date.Equals(default(DateTime)))
            {
                _transaction.Date = DateTime.Today;
            }
        }

        public static ImportNotificationTransaction PaymentRecord(Guid notificationId, 
            DateTime date, 
            decimal amount, 
            PaymentMethod paymentMethod, 
            string receiptNumber, 
            string comments)
        {
            if (paymentMethod == Core.Shared.PaymentMethod.Cheque)
            {
                Guard.ArgumentNotNullOrEmpty(() => receiptNumber, receiptNumber);
            }
            else
            {
                receiptNumber = "NA";
            }

            return new ImportNotificationTransaction
            {
                PaymentMethod = paymentMethod,
                NotificationId = notificationId,
                Date = date,
                ReceiptNumber = receiptNumber,
                Comments = comments,
                Credit = amount
            };
        }

        public Payment CreatePayment(string email, PaymentMethod payMethod, string orderAmount, string orderDescription)
        {
            Payment pay = null;

            Amount amount = new Amount();
            amount.currency = "USD";
            amount.total = orderAmount;

            Transaction transaction = new Transaction();
            transaction.amount = amount;
            transaction.description = orderDescription;

            List<Transaction> transactions = new List<Transaction>();
            transactions.Add(transaction);

            FundingInstrument fundingInstrument = new FundingInstrument();
            CreditCardToken creditCardToken = new CreditCardToken();
            creditCardToken.credit_card_id = GetSignedInUserCreditCardId(email);
            fundingInstrument.credit_card_token = creditCardToken;

            List<FundingInstrument> fundingInstrumentList = new List<FundingInstrument>();
            fundingInstrumentList.Add(fundingInstrument);

            Payer payr = new Payer();
            payr.funding_instruments = fundingInstrumentList;
            payr.payment_method = payMethod.ToString();

            Payment paymnt = new Payment();
            paymnt.intent = "sale";
            paymnt.payer = payr;
            paymnt.transactions = transactions;
            pay = paymnt.Create(Api);
            return pay;
        }

        public void GivenTheFollowingTransaction(string category, string paymentMethod, Table data)
        {
            _paymentMethodService = new PaymentMethodService(new PaymentMethodRepository(context));
            switch (_transactionType)
            {
                case TransactionTypes.Income:
                    _transaction = data.CreateInstance<Income>();
                    _transactionService = new IncomeService(new IncomeRepository(context));
                    _categoryService = new IncomeCategoryService(new IncomeCategoryRepository(context));
                    break;
                case TransactionTypes.Expense:
                    _transaction = data.CreateInstance<Expense>();
                    _transactionService = new ExpenseService(new ExpenseRepository(context));
                    _categoryService = new ExpenseCategoryService(new ExpenseCategoryRepository(context));
                    break;
            }

            _paymentMethod = _paymentMethodService.Create(paymentMethod);
            _transaction.Method = _paymentMethod;
            _transaction.PaymentMethodId = _paymentMethod.Id;

            _category = _categoryService.Create(category);
            _transaction.Category = _category;
            _transaction.CategoryId = _category.Id;
            _transaction.Date = DateTime.Today;

            _transaction.Id = 1;
            _transactionService.Create(_transaction);
        }

        public ActionResult Configure([Bind(Prefix = "Form")]PaymentConfigureForm form, string module)
        {
            var model = new PaymentConfigureViewModel();
            SetupConfigureViewModel(model, module);

            if (ModelState.IsValid)
            {
                var paymentModule = _paymentModuleManager.CreateModule(module);
                //// TODO: setup paymentModule from form values

                var method = new PaymentMethod
                {
                    Name = paymentModule.Name
                };

                _paymentModuleManager.SaveModuleToMethod(paymentModule, method);

                using (var transaction = _session.BeginTransaction())
                {
                    _session.Save(method);
                    transaction.Commit();
                }

                TempData["SuccessMessage"] = "Payment method has been activated";
                return RedirectToAction("Index");
            }

            return View(model);
        }

 public Order(Customer customer, string shippingRegion, PaymentMethod paymentMethod, DateTime placed)
 {
     Customer = customer;
     ShippingRegion = shippingRegion;
     PaymentMethod = paymentMethod;
     Placed = placed;
 }

 public Order(string id, int value, State state, decimal total, PaymentMethod paymentMethod) {
     Id = id;
     Value = value;
     State = state;
     Total = total;
     PaymentMethod = paymentMethod;
 }

        public void Pay(Guid orderId, PaymentMethod methodOfPayment, decimal amount)
        {
            if (paid.Contains(orderId))
            {
                Console.WriteLine("Free money awesome");
            }

            if (methodOfPayment == PaymentMethod.Check)
            {
                throw new InvalidOperationException("[Thread {0}] We don't take checks");
            }

            if (methodOfPayment == PaymentMethod.CreditCard)
            {
                Console.WriteLine("[Thread {0}] Please enter your pin", Thread.CurrentThread.ManagedThreadId);
                Thread.Sleep(5000);
                Console.WriteLine("[Thread {0}] Hit OK", Thread.CurrentThread.ManagedThreadId);
            }

            Console.WriteLine("[Thread {0}] Thank you!", Thread.CurrentThread.ManagedThreadId);

            paid.Add(orderId);
            bus.Publish(new PaymentReceived
                            {
                                OrderId = orderId,
                                Amount = amount
                            });
        }

 public void Equals_Name_Differs()
 {
     var first = new PaymentMethod(0, "name");
     var second = new PaymentMethod(0, "other name");
     Assert.AreNotSame(first, second);
     Assert.IsFalse(first.Equals(second));
     Assert.IsFalse(second.Equals(first));
 }

 public void Equals_All_Fields_Same()
 {
     var first = new PaymentMethod(0, "name");
     var second = new PaymentMethod(0, "name");
     Assert.AreNotSame(first, second);
     Assert.IsTrue(first.Equals(second));
     Assert.IsTrue(second.Equals(first));
 }

 public void AuthorizeCvvResponsesShouldReturnProcessorCvvResultCodeM()
 {
     defaultPaymentMethod = PaymentMethod.Create(defaultPayload.Merge(new PaymentMethodPayload() { Cvv = "111" }));
     var transaction = Processor.TheProcessor.Authorize(defaultPaymentMethod.PaymentMethodToken,
                                                        "1.00", new TransactionPayload() { BillingReference = rand });
     Assert.IsTrue( transaction.Success() );
     Assert.AreEqual( "M", transaction.ProcessorResponse.CvvResultCode );
 }

        public static PaymentMethod ToWebModel(this VirtoCommerceCartModuleWebModelPaymentMethod paymentMethod)
        {
            var paymentMethodWebModel = new PaymentMethod();

            paymentMethodWebModel.InjectFrom(paymentMethod);

            return paymentMethodWebModel;
        }

 protected void BtnCreate_Click( object sender, EventArgs e )
 {
     if ( Page.IsValid ) {
     PaymentMethod paymentMethod = new PaymentMethod( StoreId, TxtName.Text );
     paymentMethod.Save();
     base.Redirect( WebUtils.GetPageUrl( Constants.Pages.EditPaymentMethod ) + "?id=" + paymentMethod.Id + "&storeId=" + paymentMethod.StoreId );
       }
 }

        public void Update(PaymentMethod paymentMethod)
        {
            paymentMethod = Validate(paymentMethod);

            _paymentMethods.Attach(paymentMethod);
            _repository.Entry(paymentMethod).State = EntityState.Modified;
            _repository.SaveChanges();
        }

        public static coreModel.Store ToCoreModel(this webModel.Store store, ShippingMethod[] shippingMethods, PaymentMethod[] paymentMethods, TaxProvider[] taxProviders)
        {
            var retVal = new coreModel.Store();
            retVal.InjectFrom(store);
            retVal.SeoInfos = store.SeoInfos;
            retVal.StoreState = store.StoreState;
            retVal.DynamicProperties = store.DynamicProperties;

            if (store.ShippingMethods != null)
            {
                retVal.ShippingMethods = new List<ShippingMethod>();
                foreach (var shippingMethod in shippingMethods)
                {
                    var webShippingMethod = store.ShippingMethods.FirstOrDefault(x => x.Code == shippingMethod.Code);
                    if (webShippingMethod != null)
                    {
                        retVal.ShippingMethods.Add(webShippingMethod.ToCoreModel(shippingMethod));
                    }
                }
            }

            if (store.PaymentMethods != null)
            {
                retVal.PaymentMethods = new List<PaymentMethod>();
                foreach (var paymentMethod in paymentMethods)
                {
                    var webPaymentMethod = store.PaymentMethods.FirstOrDefault(x => x.Code == paymentMethod.Code);
                    if (webPaymentMethod != null)
                    {
                        retVal.PaymentMethods.Add(webPaymentMethod.ToCoreModel(paymentMethod));
                    }
                }
            }

            if (store.TaxProviders != null)
            {
                retVal.TaxProviders = new List<TaxProvider>();
                foreach (var taxProvider in taxProviders)
                {
                    var webTaxProvider = store.TaxProviders.FirstOrDefault(x => x.Code == taxProvider.Code);
                    if (webTaxProvider != null)
                    {
                        retVal.TaxProviders.Add(webTaxProvider.ToCoreModel(taxProvider));
                    }
                }
            }

            if (store.Languages != null)
                retVal.Languages = store.Languages;
            if (store.Currencies != null)
                retVal.Currencies = store.Currencies;
            if (store.ReturnsFulfillmentCenter != null)
                retVal.ReturnsFulfillmentCenter = store.ReturnsFulfillmentCenter.ToCoreModel();
            if (store.FulfillmentCenter != null)
                retVal.FulfillmentCenter = store.FulfillmentCenter.ToCoreModel();

            return retVal;
        }

 public void Update(PaymentMethod paymentMethod)
 {
     var dbCat = _context.PaymentMethods.FirstOrDefault(ec => ec.Id == paymentMethod.Id);
     if (dbCat != null)
     {
         dbCat.Name = paymentMethod.Name;
     }
     _context.SaveChanges();
 }

 public void Create(PaymentMethod paymentMethod)
 {
     if (paymentMethod == null)
     {
         return;
     }
     _context.PaymentMethods.Add(paymentMethod);
     _context.SaveChanges();
 }

		public PaymentMethod ToPaymentMethod ()
		{
			PaymentMethod paymentMethod = new PaymentMethod (bandeira);

			paymentMethod.product = produto;
			paymentMethod.installments = parcelas;

			return paymentMethod;
		}

 public void ProcessPayment(PaymentMethod paymentMethod)
 {
     Layer2Fs.CsApi.ProcessPayment(
         paymentMethod,
         () => Console.WriteLine("Paid in cash"),
         checkNo => Console.WriteLine("Paid by cheque {0}", checkNo),
         (cardType, cardNumber) => Console.WriteLine("Paid by card CardType={0}, CardNumber={1}", cardType, cardNumber)
         );
 }