public ConfigurationFactory(IStoreRepository storeRepository)
{
var config = ConfigurationManager.GetSection("commerceEngine") as CommerceEngineConfigurationSection;
if (config == null)
{
return;
}
this._paymentProvider = Activator.CreateInstance(Type.GetType(config.PaymentProvider.Type)) as IPaymentProvider;
if (this._paymentProvider != null)
{
this._paymentProvider.Login = config.PaymentProvider.Login;
this._paymentProvider.Password = config.PaymentProvider.Password;
}
this._mailingProvider = Activator.CreateInstance(Type.GetType(config.MailingProvider.Type)) as IMailingProvider;
if (this._mailingProvider != null)
{
this._mailingProvider.FromAddress = config.MailingProvider.FromAddress;
this._mailingProvider.SmtpServer = config.MailingProvider.SmtpServer;
}
this._shippingProvider = Activator.CreateInstance(Type.GetType(config.ShippingProvider.Type)) as IShippingProvider;
this._commerceEvents = new CommerceEvents();
foreach (ProviderSettings element in config.Modules)
{
var module = Activator.CreateInstance(Type.GetType(element.Type)) as ICommerceModule;
module?.Initialize(this._commerceEvents, element.Parameters);
}
}
public void IsPaymentMethodActive_NullProvider_ThrowException()
{
IPaymentProvider provider = null;
var settings = new PaymentSettings();
Assert.ThrowsException <ArgumentNullException>(() => provider.IsPaymentMethodActive(settings));
}
public ShoppingCartController(IShoppingCartRepository repository, IPaymentProvider paymentProvider, INotificationProvider notificationProvider, ShoppingCartContext shoppingCartContext)
{
_repository = repository;
_paymentProvider = paymentProvider;
_notificationProvider = notificationProvider;
_shoppingCartContext = shoppingCartContext;
}
public BillingEventArgs(Customer customer, OrderData orderData, int shippingCost, IPaymentProvider paymentProvider)
{
this.Customer = customer;
this.OrderData = orderData;
this.ShippingCost = shippingCost;
this.PaymentProvider = paymentProvider;
}
protected void Page_Init(object sender, EventArgs e)
{
// REDIRECT IF NO PROVIDER AVAILABLE
_PaymentGatewayId = AlwaysConvert.ToInt(Request.QueryString["PaymentGatewayId"]);
_PaymentGateway = PaymentGatewayDataSource.Load(_PaymentGatewayId);
if (_PaymentGateway == null)
{
Response.Redirect("Gateways.aspx");
}
_ProviderInstance = _PaymentGateway.GetInstance();
if (_ProviderInstance == null)
{
Response.Redirect("Gateways.aspx");
}
// INITIALIZE THE FORM
Caption.Text = string.Format(Caption.Text, _ProviderInstance.Name);
// DETERMINE IF PAYMENT METHODS SHOULD SHOW FOR THIS PROVIDER
if (ShowPaymentMethods(_PaymentGateway))
{
LoadPaymentMethods();
}
else
{
trPaymentMethods.Visible = false;
}
}
public async Task Denizbank_GetPaymentParameterResult_Success()
{
ServiceCollection serviceCollection = new ServiceCollection();
serviceCollection.AddHttpClient();
ServiceProvider serviceProvider = serviceCollection.BuildServiceProvider();
PaymentProviderFactory paymentProviderFactory = new PaymentProviderFactory(serviceProvider);
IPaymentProvider provider = paymentProviderFactory.Create(BankNames.DenizBank);
var paymentGatewayResult = await provider.ThreeDGatewayRequest(new PaymentGatewayRequest
{
CardHolderName = "Sefa Can",
CardNumber = "4508-0345-0803-4509",
ExpireMonth = 12,
ExpireYear = 21,
CvvCode = "000",
Installment = 1,
CardType = "1",
TotalAmount = 1.60m,
CustomerIpAddress = "127.0.0.1",
CurrencyIsoCode = "949",
LanguageIsoCode = "tr",
OrderNumber = Guid.NewGuid().ToString(),
BankName = BankNames.IsBankasi,
BankParameters = provider.TestParameters,
CallbackUrl = new Uri("https://google.com")
});
Assert.True(paymentGatewayResult.Success);
}
protected void Page_Load(object sender, EventArgs e)
{
// verify the provider is configured
_AmazonProvider = GetAmazonProvider();
if (_AmazonProvider == null)
{
Response.Redirect(NavigationHelper.GetBasketUrl());
}
// package the basket on first visit
Basket basket = AbleContext.Current.User.Basket;
if (!Page.IsPostBack)
{
IBasketService basketService = AbleContext.Resolve <IBasketService>();
basketService.Package(basket, true);
basketService.Combine(basket);
foreach (var shipment in basket.Shipments)
{
shipment.ShipMethod = null;
}
basket.Save();
basketService.Recalculate(basket);
}
// bind the amazon widgets
MethodInfo buttonMethod = _AmazonProvider.GetType().GetMethod("GetAddressWidget");
string eventHandler = "document.getElementById('" + RecalculateShippingButton.ClientID + "').click();";
object[] parameters = new object[] { basket, eventHandler, false };
PlaceHolder addressWidget = (PlaceHolder)buttonMethod.Invoke(_AmazonProvider, parameters);
this.ShippingAddress.Controls.Add(addressWidget);
BindBasketGrid();
}
private void SaveGateWay()
{
_PaymentGateway.UpdateConfigData(this.GetConfigData());
_PaymentGateway.Save();
_ProviderInstance = _PaymentGateway.GetInstance();
if (ShowPaymentMethods(_PaymentGateway))
{
//UPDATE PAYMENT METHODS
int index = 0;
foreach (DataListItem item in PaymentMethodList.Items)
{
int paymentMethodId = AlwaysConvert.ToInt(PaymentMethodList.DataKeys[index]);
PaymentMethod method = GetPaymentMethod(paymentMethodId);
if (method != null)
{
CheckBox cbMethod = (CheckBox)AbleCommerce.Code.PageHelper.RecursiveFindControl(item, "Method");
if (cbMethod.Checked)
{
method.PaymentGateway = PaymentGatewayDataSource.Load(_PaymentGatewayId);
}
else if (method.PaymentGateway != null && method.PaymentGateway.Id == _PaymentGatewayId)
{
method.PaymentGateway = null;
}
method.Save();
}
index++;
}
}
}
/// <summary>
/// Is payment method active?
/// </summary>
/// <param name="paymentMethod">Payment method</param>
/// <param name="paymentSettings">Payment settings</param>
/// <returns>Result</returns>
public static bool IsPaymentMethodActive(this IPaymentProvider paymentMethod,
PaymentSettings paymentSettings)
{
if (paymentMethod == null)
{
throw new ArgumentNullException(nameof(paymentMethod));
}
if (paymentSettings == null)
{
throw new ArgumentNullException(nameof(paymentSettings));
}
if (paymentSettings.ActivePaymentProviderSystemNames == null)
{
return(false);
}
foreach (var activeMethodSystemName in paymentSettings.ActivePaymentProviderSystemNames)
{
if (paymentMethod.SystemName.Equals(activeMethodSystemName, StringComparison.OrdinalIgnoreCase))
{
return(true);
}
}
return(false);
}
public void SetUp()
{
_inventoryService = Mock.Create <ICheckInventory>();
_paymentProvider = Mock.Create <IPaymentProvider>();
_sendEmailService = Mock.Create <ISendEmail>();
_cart = new Cart(_inventoryService, _paymentProvider, _sendEmailService);
}
public void SetUp()
{
_cashPayment = new CashPayment();
_nets = Substitute.ForPartsOf <Nets>();
_nets.When(x => x.TransferAmount(Arg.Any <int>(), Arg.Any <string>())).DoNotCallBase();
_nets.TransferAmount(Arg.Any <int>(), Arg.Any <string>()).Returns(false);
_paymentProviders = new List <IPaymentProvider> {
_cashPayment, _nets
};
_fakePaymentDao = Substitute.For <IPaymentDao>();
_fakeReceiptController = Substitute.For <IReceiptController>();
_fakeCashDrawer = Substitute.For <ICashDrawer>();
_fakeCashDrawer.CashChange.Returns(1000);
_uut = new PaymentController(_paymentProviders, _fakeReceiptController, _fakePaymentDao, _fakeCashDrawer);
_cashTransaction = new Transaction()
{
Description = "noget",
PaymentType = PaymentType.Cash,
Price = 100,
};
_netTransaction = new Transaction()
{
Description = "noget",
PaymentType = PaymentType.Nets,
Price = 100,
};
}
public IActionResult ProcessCheckout(CheckoutModel model)
{
// get the selected provider
IPaymentProvider provider = _pluginClassesService.GetPluginClasses <IPaymentProvider>()
.Where(p => p.UniqueId().CompareTo(model.SelectedProviderId) == 0).FirstOrDefault();
if (provider == null)
{
throw new InvalidOperationException(Middleware.Constants.PaymentProviderNotFound);
}
ShoppingCartDetail cartDetails = _shoppingCartProvider.GetDetail(GetCartSummary().Id);
UserSession session = GetUserSession();
if (_shoppingCartProvider.ConvertToOrder(cartDetails, session.UserID, out Order order))
{
if (provider.Execute(HttpContext.Request, order, PaymentStatus.Unpaid, session, out string providerUrl))
{
session.Tag = order.Id;
return(Redirect(providerUrl));
}
}
return(RedirectToAction(nameof(Failed)));
}
public PaymentServiceMakePaymentTests()
{
_input = new Payment
{
Amount = 120.49m,
CardNumber = "1234-1234-1234-1234",
Currency = Currency.GBP,
CVV = 333,
ExpiryYear = DateTime.Now.Year + 1,
ExpiryMonth = DateTime.Now.Month + 1
};
_paymentProcessResults = new PaymentProcessResults
{
Success = true,
TranscactionIdentifier = "111111111111111",
};
_paymentRepository = Substitute.For <IPaymentRepository>();
_paymentProvider = Substitute.For <IPaymentProvider>();
_paymentProviderFactory = Substitute.For <IPaymentProviderFactory>();
_paymentRepository.Create(Arg.Do <Payment>(p => _persistedPayment = p));
_paymentProvider.ProcessPayment(Arg.Any <Payment>()).Returns(_paymentProcessResults);
_paymentProviderFactory.Create(Arg.Any <string>()).Returns(_paymentProvider);
_target = new PaymentService(_paymentRepository, new BusinessRulesValidator(), _paymentProviderFactory);
}
/// <summary>
/// Calculate payment method fee
/// </summary>
/// <param name="paymentMethod">Payment method</param>
/// <param name="orderTotalCalculationService">Order total calculation service</param>
/// <param name="cart">Shopping cart</param>
/// <param name="fee">Fee value</param>
/// <param name="usePercentage">Is fee amount specified as percentage or fixed value?</param>
/// <returns>Result</returns>
public static async Task <decimal> CalculateAdditionalFee(this IPaymentProvider paymentMethod,
IOrderCalculationService orderTotalCalculationService, IList <ShoppingCartItem> cart,
decimal fee, bool usePercentage)
{
if (paymentMethod == null)
{
throw new ArgumentNullException(nameof(paymentMethod));
}
if (fee <= 0)
{
return(fee);
}
decimal result;
if (usePercentage)
{
//percentage
var shoppingCartSubTotal = await orderTotalCalculationService.GetShoppingCartSubTotal(cart, true);
result = (decimal)((((float)shoppingCartSubTotal.subTotalWithDiscount) * ((float)fee)) / 100f);
}
else
{
//fixed value
result = fee;
}
return(result);
}
public void SetUp()
{
_paymentProvider = Substitute.For <IPaymentProvider>();
_emailGateway = Substitute.For <IEmailGateway>();
_transactionRepo = Substitute.For <TransactionRepo>();
_paymentService = new PaymentService(_paymentProvider, _emailGateway, _transactionRepo);
_customerId = "Cust-2345";
}
public Cart(ICheckInventory inventoryService,
IPaymentProvider paymentProvider,
ISendEmail sendEmailService)
{
this._sendEmailService = sendEmailService;
this._paymentProvider = paymentProvider;
this._inventoryService = inventoryService;
}
public CommerceService(IExtCommonDao commonDao, ICommerceDao dao, IPaymentProvider provider, IBasketRules rules, IOrderProcessorFactory processorFactory, ITemplateEngine templateEngine, IChargeService chargeService) {
_commonDao = commonDao;
_dao = dao;
_provider = provider;
_rules = rules;
_chargeService = chargeService;
_processorFactory = processorFactory;
}
public ChargePaymentConsumer(IEventBus eventBus, IPaymentProvider paymentProvider,
IPaymentDetailsRepository paymentDetailsRepository, PaymentDetailsContext context)
{
_eventBus = eventBus;
_paymentProvider = paymentProvider;
_paymentDetailsRepository = paymentDetailsRepository;
_context = context;
}
public PaymentService(IChapterRepository chapterRepository, IPaymentProvider paymentProvider, ICountryRepository countryRepository,
IPaymentRepository paymentRepository)
{
_chapterRepository = chapterRepository;
_countryRepository = countryRepository;
_paymentProvider = paymentProvider;
_paymentRepository = paymentRepository;
}
public static void Main(string[] args)
{
handler = new ConsoleEventDelegate(ConsoleEventCallback);
SetConsoleCtrlHandler(handler, true);
IHost host = CreateHostBuilder(args).Build();
IEventBroker broker = host.Services.GetRequiredService <IEventBroker>(); // initialize evenk broker
// instantiate mediators
OrderingMediator mediator = host.Services.GetRequiredService <OrderingMediator>();
PaymentMediator paymentMediator = host.Services.GetRequiredService <PaymentMediator>();
// POC
Task.Run(() =>
{
Thread.Sleep(1500);
IAttendant att = host.Services.GetRequiredService <IAttendant>();
att.StartOrder(b => b.WithHeader("TST123456", "9262147116", "IVG", Locale.Latvia, Lang.Lv)
.WithObtainingMethod(GoodsObtainingMethod.Warehouse)
.WithItems(OrderLine.Create("0141", Money.Create(10.0m, CurrencyCode.Euro)))
.WithTotalValues(Money.Create(10.0m, CurrencyCode.Euro), 15.95m)
.WithExtraData("Kiosk", "LRK0123456")
.WithExtraData("SelectedMonth", "february 2021"));
IPaymentProvider paymentProvider = host.Services.GetRequiredService <IPaymentProvider>();
ICashPaymentService cashPaymentService = host.Services.GetRequiredService <ICashPaymentService>(); // пользователь выбрал оплату кешем (не payment provider так решил, а пользователь)
paymentProvider.Collect(PaymentSource.UVS, att.Order, (p) => { });
Task.Factory.StartNew(() =>
{
Thread.Sleep(10000);
att.CompleteOrder();
});
/*IStorageService s2 = host.Services.GetRequiredService<IStorageService>();
*
* ICompositeDispenser dispenser = host.Services.GetRequiredService<ICompositeDispenser>();
*
* ILayout layout = host.Services.GetRequiredService<ILayout>();
* if (layout == null)
* {
* var t = s2.Get(x => true);
* }
*
* dispenser.OnDispensing += S1_OnDispensing;
*
* dispenser.Dispense(CompositDispenseAddress.Create(vendingMachineId: layout.Machines.First().Number.ToString(), layout.Machines.First().Trays.First().Belts.First().Address));
*
* dispenser.OnDispensing -= S1_OnDispensing;*/
});
host.Run();
}
public async Task <IntegrityCheckResult> ValidateAsync(FormSchema schema)
{
IntegrityCheckResult result = new();
bool containsPayment = schema.Pages
.Where(page => page.Behaviours is not null)
.SelectMany(page => page.Behaviours)
.Any(page => page.BehaviourType.Equals(EBehaviourType.SubmitAndPay));
if (!containsPayment)
{
return(result);
}
List <PaymentInformation> paymentInformation = await _paymentConfigProvider.Get <List <PaymentInformation> >();
PaymentInformation formPaymentInformation = paymentInformation.FirstOrDefault(payment => payment.FormName.Equals(schema.BaseURL));
if (formPaymentInformation is null)
{
result.AddFailureMessage($"PaymentConfiguration::No payment information configured.");
return(result);
}
IPaymentProvider paymentProvider = _paymentProviders
.FirstOrDefault(provider => provider.ProviderName
.Equals(formPaymentInformation.PaymentProvider));
if (paymentProvider is null)
{
result.AddFailureMessage($"PaymentConfiguration::No payment provider configured for provider '{formPaymentInformation.PaymentProvider}'");
return(result);
}
if (formPaymentInformation.Settings.CalculationSlug is not null &&
!string.IsNullOrEmpty(formPaymentInformation.Settings.Amount))
{
result.AddFailureMessage("PaymentConfiguration::Only amount or calculationSlug can be provided");
return(result);
}
if (formPaymentInformation.Settings.CalculationSlug is null &&
string.IsNullOrEmpty(formPaymentInformation.Settings.Amount))
{
result.AddFailureMessage("PaymentConfiguration::Either amount or calculationSlugs must be provided");
return(result);
}
if (formPaymentInformation.Settings.CalculationSlug is not null)
{
if (!_environment.IsEnvironment("local") && !formPaymentInformation.Settings.CalculationSlug.URL.StartsWith("https://"))
{
result.AddFailureMessage("PaymentConfiguration::CalculateCostUrl must start with https");
}
}
return(result);
}
public PaymentsController()
:base()
{
this.paymentProvider = ProviderService.GetProvider();
this.antiForgeryService = new AntiForgeryService();
this.engineService = new EngineService();
System.Net.ServicePointManager.SecurityProtocol |= SecurityProtocolType.Tls11 | SecurityProtocolType.Tls12;
}
public void AddProvider(IPaymentProvider provider)
{
if (provider == null)
{
throw new ArgumentException(nameof(provider));
}
providers.Add(provider);
}
public PaymentController(
ILogger <PaymentController> logger,
IPaymentProvider paymentProvider)
{
_logger = logger;
_paymentProvider = paymentProvider;
logger.LogInformation("Payment Controller is called");
}
public PaymentProviderTestDecorator(IPaymentProvider provider) {
_provider = provider;
//Copy known properties
this.MerchantID = _provider.MerchantID;
this.MerchantPassword = _provider.MerchantPassword;
this.Mode = _provider.Mode;
}
public void PaymentProviderFactory_CreateAssecoPaymentProvider(int bankId)
{
ServiceCollection serviceCollection = new ServiceCollection();
ServiceProvider serviceProvider = serviceCollection.BuildServiceProvider();
PaymentProviderFactory paymentProviderFactory = new PaymentProviderFactory(serviceProvider);
IPaymentProvider provider = paymentProviderFactory.Create((BankNames)bankId);
Assert.IsType <NestPayPaymentProvider>(provider);
}
public void PaymentProviderFactory_CreateGarantiPaymentProvider()
{
ServiceCollection serviceCollection = new ServiceCollection();
ServiceProvider serviceProvider = serviceCollection.BuildServiceProvider();
PaymentProviderFactory paymentProviderFactory = new PaymentProviderFactory(serviceProvider);
IPaymentProvider provider = paymentProviderFactory.Create(BankNames.Garanti);
Assert.IsType <GarantiPaymentProvider>(provider);
}
public static Task <PaymentProviderEndPaymentResponse> EndPaymentAsync(this IPaymentProvider provider, System.Web.HttpRequestBase request)
{
var data = request.ToDictionary(RequestRead.QueryAndForm);
data.Add("HttpMethod", request.HttpMethod);
data.Add("Url", request.Url.AbsoluteUri);
return(provider.EndPaymentAsync(data, CancellationToken.None));
}
public static bool CanEnd(this IPaymentProvider provider, System.Web.HttpRequestBase request)
{
var data = request.ToDictionary(RequestRead.QueryAndForm);
data.Add("HttpMethod", request.HttpMethod);
data.Add("Url", request.Url.AbsoluteUri);
return(provider.CanEnd(data));
}
public void PaymentProviderFactory_CreateAssecoPaymentProvider()
{
ServiceCollection serviceCollection = new ServiceCollection();
ServiceProvider serviceProvider = serviceCollection.BuildServiceProvider();
PaymentProviderFactory paymentProviderFactory = new PaymentProviderFactory(serviceProvider);
IPaymentProvider provider = paymentProviderFactory.Create(BankNames.DenizBank);
Assert.IsType <DenizbankPaymentProvider>(provider);
}
public CommerceManager(IStoreRepository storeRepository, IConfigurationFactory configurationFactory)
{
this._storeRepository = storeRepository;
this._mailingProvider = configurationFactory.GetMailer();
this._paymentProvider = configurationFactory.GetPaymentProcessor();
this._shippingProvider = configurationFactory.GetShippingProcessor();
this._commerceEvents = configurationFactory.GetCommerceEvents();
}
protected string GetConfigReference(object dataItem)
{
IPaymentProvider provider = ((PaymentGateway)dataItem).GetInstance();
if (provider != null)
{
return(provider.ConfigReference);
}
return(string.Empty);
}
public static IPaymentProvider GetPaymentProvider(string provider = null)
{
if (Configuration.IsMock)
_provider = new MockPaymentProvider();
else
{
var paymentDataProvider = PaymentDataProviderFactory.CreatePaymentDataProvider();
var paymentProviderDetails =
paymentDataProvider.GetPaymentProviderDetails(provider ?? ConfigSettings.DefaultPaymentProvider, ConfigSettings.PaymentProviderMode);
if (paymentProviderDetails == null)
return null;
if (string.Equals(paymentProviderDetails.Provider, "EBS", StringComparison.OrdinalIgnoreCase))
_provider = new EbsPaymentProvider(paymentProviderDetails);
else if (string.Equals(paymentProviderDetails.Provider, "PayU", StringComparison.OrdinalIgnoreCase))
_provider = new PayUPaymentProvider(paymentProviderDetails);
}
return _provider;
}
public void Initialize()
{
paymentProvider = new FakePaymentProvider();
}
public void SetUp()
{
_uut = new Nets();
}
public void SetUp()
{
_uut = new MobilePay();
}
public void SetUp()
{
provider = new AuthorizePaymentProvider(TEST_API_URL, TEST_ARB_API_URL, TEST_LOGIN_ID, TEST_TRANSACTION_KEY);
}
public void ProcessPayment(string orderData, IPaymentProvider paymentProvider)
{
var result = paymentProvider.Execute(orderData);
MessageBox.Show(result.ToString());
}
public PaymentLogic(ref Orders Order)
{
var OrderPaymentMethod = Order.PaymentMethod;
SiteDbContext db = new SiteDbContext();
var PaymentMethodDetails = db.PaymentMethods.Where(p => p.Type == OrderPaymentMethod).FirstOrDefault();
NameValueCollection Parameters = new NameValueCollection();
if (PaymentMethodDetails!= null && PaymentMethodDetails.Parameters != null)
{
Parameters = HttpUtility.ParseQueryString(PaymentMethodDetails.Parameters.ToLower());
}
if (EqualPayment(Order.PaymentMethod, PaymentMethodsEnum.PayPal))
{
PaymentProvider = new PayPalProvider(Order, Parameters);
}
else if (EqualPayment(Order.PaymentMethod, PaymentMethodsEnum.CreditCard))
{
PaymentProvider = new ZCreditProvider(Order, Parameters);
}
else if(EqualPayment(Order.PaymentMethod,PaymentMethodsEnum.Bitcoin))
{
PaymentProvider = new CoinbaseProvider(Order, Parameters);
}
}
public void SetUp()
{
_cashPayment = new CashPayment();
_nets = Substitute.ForPartsOf<Nets>();
_nets.When(x => x.TransferAmount(Arg.Any<int>(), Arg.Any<string>())).DoNotCallBase();
_nets.TransferAmount(Arg.Any<int>(), Arg.Any<string>()).Returns(false);
_paymentProviders = new List<IPaymentProvider> {_cashPayment, _nets};
_fakePaymentDao = Substitute.For<IPaymentDao>();
_fakeReceiptController = Substitute.For<IReceiptController>();
_fakeCashDrawer = Substitute.For<ICashDrawer>();
_fakeCashDrawer.CashChange.Returns(1000);
_uut = new PaymentController(_paymentProviders, _fakeReceiptController, _fakePaymentDao, _fakeCashDrawer);
_cashTransaction = new Transaction()
{
Description = "noget",
PaymentType = PaymentType.Cash,
Price = 100,
};
_netTransaction = new Transaction()
{
Description = "noget",
PaymentType = PaymentType.Nets,
Price = 100,
};
}
