コード例 #1
0
        public static bool RegisterPaymentHandler(IPaymentHandler handler)
        {
            _facade = new SDKPaymentFacade(handler);

            PaymentHandlerAsync.RegisterPaymentMethodAsync(_facade).Wait();

            return(true);
        }
コード例 #2
0
 public CheckoutModel(IPaymentHandler payment, ICart cart, UserManager <ApplicationUser> userManager, IOrder order, IOrderItem orderItem, ICartItem cartItem, IEmail email)
 {
     _payment     = payment;
     _cart        = cart;
     _cartItem    = cartItem;
     _userManager = userManager;
     _order       = order;
     _orderItem   = orderItem;
     _email       = email;
 }
コード例 #3
0
        public ConfirmOrder ConfirmOrder(
            EventAggregator eventAggregator,
            IEmailSender emailSender,
            IPaymentHandler paymentHandler)
        {
            var confirmOrder = new ConfirmOrder(
                new HandleSendEmail(eventAggregator, emailSender),
                new HandleMakePayment(eventAggregator, paymentHandler));

            eventAggregator.Register(confirmOrder);

            return(confirmOrder);
        }
コード例 #4
0
 public SDKPaymentFacade(IPaymentHandler handler)
 {
     _handler = handler;
     CreatePaymentAddressCallback           = CreatePaymentAddressHandler;
     AddRequestFeesCallback                 = AddRequestFeesHandler;
     ParseResponseWithFeesCallback          = ParseResponseWithFeesHandler;
     BuildGetPaymentSourcesRequstCallback   = BuildGetPaymentSourcesRequstHandler;
     ParseGetPaymentSourcesResponseCallback = ParseGetPaymentSourcesResponseHandler;
     BuildPaymentRequestCallback            = BuildPaymentRequestHandler;
     ParsePaymentResponseCallback           = ParsePaymentResponseHandler;
     BuildMintReqCallback               = BuildMintReqHandler;
     BuildSetTxnFeesReqCallback         = BuildSetTxnFeesReqHandler;
     BuildGetTxnFeesReqCallback         = BuildGetTxnFeesReqHandler;
     ParseGetTxnFeesResponseCallback    = ParseGetTxnFeesResponseHandler;
     BuildVerifyPaymentRequestCallback  = BuildVerifyPaymentRequestHandler;
     ParseVerifyPaymentResponseCallback = ParseVerifyPaymentResponseHandler;
 }
コード例 #5
0
        /// <summary>
        /// Ensures LibIndy understand DotNetPay will respond to payment API handler
        /// requests for payment address of "DNP"
        ///
        /// The LibIndy pattern is consumers explicityly tell the payment
        /// libraries to register with LibIndy.  LibIndy does not automatically
        /// discover payment libraries.
        ///
        /// THEREFORE to use DotNetPay, call this method
        /// </summary>
        /// <returns>true if regisration of DotNetPay succeeds with LibIndy</returns>
        public static bool Register()
        {
            if (null != _handler)
            {
                Logger.Warn("DotNetPay Payment Handler is already registered");
                return(true);
            }

            Logger.Info("Registering DotNetPay Payment Handlers");
            var  handler = new PaymentHandler();
            bool registeredSuccessfully = Factory.RegisterPaymentHandler(handler);

            // only save instance if handler succeeded in registering
            if (registeredSuccessfully)
            {
                _handler = handler;
            }

            return(registeredSuccessfully);
        }
コード例 #6
0
 public PaymentProcessor(IPaymentHandler paymentProcessingChain)
 {
     paymentProcessingChainFirstElement = paymentProcessingChain;
 }
コード例 #7
0
ファイル: OrdersAction.cs プロジェクト: tartor/StrataTest
        //supply the actual class that will handle the payment and courier
        // example calls
        // Create(new PaymentHandler1(), new CourierHandler1())
        // Create(new PaymentHandler2(), new CourierHandler2())
        // the right class can be chossen from the caller based on config string or defined web provider class

        public bool Create(IPaymentHandler paymentHandler, ICourierHandler courierHandler)
        {
            if (paymentHandler == null || courierHandler == null)
            {
                return(false);
            }

            // check if the customer has products in the cart
            CartModel          cartModel = new CartModel();
            IEnumerable <Cart> carts     = cartModel.Get(base.Customer.Name);

            if (carts == null && carts.Count() <= 0)
            {
                return(false);
            }

            // calculate the amount have to pay
            double dAmount = carts.Sum(c => c.Quantity * c.UnitPrice);

            if (dAmount <= 0)
            {
                return(false);
            }

            // check for discount
            DiscountModel discountModel = new DiscountModel();
            Discount      discount      = discountModel.Get(base.Customer.Name);

            if (discount != null && discount.Percentage != 0)
            {
                dAmount -= Math.Round((dAmount * discount.Percentage) / 100, 2);
                System.Diagnostics.Debug.Assert(dAmount > 0);
            }

            //try to make a payment
            if (!paymentHandler.MakePayment(base.Customer.Name, dAmount))
            {
                return(false);
            }

            //make the cart into an order
            OrderModel orderModel = new OrderModel();
            string     sID        = orderModel.Add(base.Customer.Name, base.Customer.Address, dAmount);

            if (sID == null)
            {
                return(false);
            }

            OrderLinesModel orderLinesModel = new OrderLinesModel();

            foreach (Cart cart in carts)
            {
                if (!orderLinesModel.Add(sID, cart.ProductCode, cart.Quantity, cart.UnitPrice))
                {
                    orderModel.Delete(sID);
                    orderLinesModel.Delete(sID);
                    return(false);
                }
            }

            //clear the cart for this customer
            cartModel.Delete(base.Customer.Name);

            // get the order and the order items
            Order order = orderModel.Get(sID);
            IEnumerable <OrderLine> orderLines = orderLinesModel.GetAll(sID);

            // send email confirmation to the customer
            EmailHandler emailhandler = new EmailHandler();

            emailhandler.SendOrderConfirmation(base.Customer, order, orderLines);

            // Notify the Courier
            courierHandler.Deliver(order, orderLines);

            return(true);
        }
コード例 #8
0
 public PaymentController(IPaymentHandler paymentHandler)
 {
     _paymentHandler = paymentHandler;
 }
コード例 #9
0
 public IPaymentHandler SetNext(IPaymentHandler handler)
 {
     _nextHanlder = handler;
     return(handler);
 }
コード例 #10
0
ファイル: DefaultShell.cs プロジェクト: andypike/Castlecasts
 public DefaultShell(ILoggingService loggingService, IPaymentHandler paymentHandler)
 {
     this.loggingService = loggingService;
     this.paymentHandler = paymentHandler;
 }
コード例 #11
0
 public PaymentProcessingController(ILogger <PaymentProcessingController> logger, IPaymentHandler paymentHandler)
 {
     _logger         = logger;
     _paymentHandler = paymentHandler;
 }
コード例 #12
0
 public DefaultShell(ILoggingService loggingService, IPaymentHandler paymentHandler)
 {
     this.loggingService = loggingService;
     this.paymentHandler = paymentHandler;
 }
コード例 #13
0
 public HandleMakePayment(EventAggregator eventAggregator, IPaymentHandler paymentHandler)
 {
     _eventAggregator = eventAggregator;
     _paymentHandler  = paymentHandler;
 }
コード例 #14
0
 public PaymentController(IPaymentHandler paymentHandler, IMapper mapper)
 {
     _paymentHandler = paymentHandler;
     _mapper         = mapper;
 }
コード例 #15
0
 public void SetNext(IPaymentHandler handler)
 {
     nextHandler = handler;
 }
コード例 #16
0
 public PaymentProcessorController(IPaymentHandler handler)
 {
     _handler = handler;
 }
コード例 #17
0
ファイル: PaymentService.cs プロジェクト: tah91/eworkyWebSite
        public string PayWithPayPal(int id, 
                                    string returnUrl, 
                                    string cancelUrl, 
                                    string ipnUrl, 
                                    string senderEmail, 
                                    IEnumerable<PaymentItem> payments,
                                    IPaymentHandler paymentHandler,
                                    PaymentConstants config)
        {
            HttpWebRequest request;
            WebResponse response = null;
            StreamReader reader = null;

            string resultUrl = null;

            try
            {
                request = CreatePaypalRequest(PayPalConstants.MessageFormat.NameValue, PayPalConstants.MessageFormat.Xml, config);
                request.Method = "POST";
                request.ContentType = "application/x-www-form-urlencoded";

                string postData = "&actionType=PAY";
                postData += "&senderMail=" + senderEmail;
                postData += "&cancelUrl=" + cancelUrl;
                postData += "&ipnNotificationUrl=" + ipnUrl;
                postData += "&currencyCode=" + "EUR";
                postData += "&feesPayer=" + PayPalConstants.FeePayer.EachReceiver;

                foreach (var payment in payments)
                {
                    postData += "&receiverList.receiver(" + payment.Index.ToString() + ").amount=" + payment.Amount.ToString("F");
                    postData += "&receiverList.receiver(" + payment.Index.ToString() + ").email=" + payment.Email;
                }

                postData += "&requestEnvelope.errorLanguage=" + "en_US";
                postData += "&returnUrl=" + returnUrl;

                byte[] byteArray = Encoding.UTF8.GetBytes(postData);
                request.ContentLength = byteArray.Length;

                Stream dataStream = request.GetRequestStream();
                dataStream.Write(byteArray, 0, byteArray.Length);
                dataStream.Close();

                response = request.GetResponse();

                dataStream = response.GetResponseStream();

                reader = new StreamReader(dataStream);
                string responseFromServer = reader.ReadToEnd();

                XmlDocument xdoc = new XmlDocument();
                xdoc.LoadXml(responseFromServer);

                XmlNodeList nodes = xdoc.GetElementsByTagName("ack");

                if (nodes.Count > 0)
                {
                    string ackMessage = nodes[0].InnerText;

                    if (!string.IsNullOrEmpty(ackMessage))
                    {
                        nodes = xdoc.GetElementsByTagName("payKey");

                        if (nodes.Count > 0)
                        {
                            string payKey = nodes[0].InnerText.Trim();

                            if (ackMessage.ToLower() == "success")
                            {
                                if (paymentHandler.CreateTransactions(id, payKey, payments))
                                {
                                    resultUrl = config.ApprovalUrl + payKey;
                                }
                            }
                            else
                            {
                                _Logger.Error("Paypal: API call failure\r\n" + responseFromServer);
                            }
                        }
                        else
                        {
                            throw new Exception("Paypal: invalid API response XML format");
                        }
                    }
                    else
                    {
                        throw new Exception("Paypal: invalid API response XML format");
                    }
                }
                else
                {
                    throw new Exception("Paypal: invalid API response XML format");
                }
            }
            catch (Exception ex)
            {
                _Logger.Error(ex.Message);
            }
            finally
            {
                if (reader != null)
                {
                    reader.Close();
                }

                if (response != null)
                {
                    response.Close();
                }
            }

            return resultUrl;
        }