public override VoidProcessPaymentResult VoidProcessPayment(VoidProcessPaymentEvaluationContext context)
        {
            var retVal = new VoidProcessPaymentResult();

            if (context.Payment.PaymentStatus == PaymentStatus.Cancelled)
            {
                var request = new VoidRequest(context.Payment.OuterId);
                var gate    = new Gateway(ApiLogin, TxnKey, true);

                var response = gate.Send(request);

                if (response.Approved)
                {
                    context.Payment.IsCancelled = true;
                    retVal.IsSuccess            = true;
                    retVal.NewPaymentStatus     = context.Payment.PaymentStatus = PaymentStatus.Voided;
                    context.Payment.VoidedDate  = context.Payment.CancelledDate = DateTime.UtcNow;
                }
                else
                {
                    retVal.ErrorMessage = response.Message;
                }
            }
            else
            {
                throw new NullReferenceException("Only authorized payments can be voided");
            }
            return(retVal);
        }
 public override VoidProcessPaymentResult VoidProcessPayment(VoidProcessPaymentEvaluationContext context)
 {
     context.Payment.IsApproved    = false;
     context.Payment.PaymentStatus = PaymentStatus.Voided;
     context.Payment.VoidedDate    = DateTime.UtcNow;
     context.Payment.IsCancelled   = true;
     context.Payment.CancelledDate = DateTime.UtcNow;
     return(new VoidProcessPaymentResult {
         IsSuccess = true, NewPaymentStatus = PaymentStatus.Voided
     });
 }
 public override VoidProcessPaymentResult VoidProcessPayment(VoidProcessPaymentEvaluationContext context)
 {
     context.Payment.IsApproved = false;
     //The PaymentStatus doesn't copied to Payment.Status during save so we need set it for backward compatibility
     context.Payment.PaymentStatus = PaymentStatus.Voided;
     context.Payment.Status        = PaymentStatus.Voided.ToString();
     context.Payment.VoidedDate    = DateTime.UtcNow;
     context.Payment.IsCancelled   = true;
     context.Payment.CancelledDate = DateTime.UtcNow;
     return(new VoidProcessPaymentResult {
         IsSuccess = true, NewPaymentStatus = PaymentStatus.Voided
     });
 }
Example #4
0
        public override VoidProcessPaymentResult VoidProcessPayment(VoidProcessPaymentEvaluationContext context)
        {
            var retVal = new VoidProcessPaymentResult();

            Hashtable request = new Hashtable();

            request.Add("ccAuthReversalService_run", "true");
            request.Add("ccAuthReversalService_authRequestID", context.Payment.OuterId);
            request.Add("merchantID", MerchantId);
            request.Add("merchantReferenceCode", context.Payment.Number);
            request.Add("purchaseTotals_currency", context.Payment.Currency.ToString());
            request.Add("item_0_unitPrice", context.Payment.Sum.ToString());
            //request.Add("item_0_quantity", "1");

            var reply = NVPClient.RunTransaction(request);

            if (reply != null && reply.ContainsKey("decision") && reply.ContainsKey("reasonCode"))
            {
                var decision            = (string)reply["decision"];
                var reasonCode          = int.Parse((string)reply["reasonCode"]);
                var isAccept            = decision.Equals("ACCEPT", StringComparison.InvariantCultureIgnoreCase);
                var isSuccessReasonCode = reasonCode == 100;
                if (isAccept && isSuccessReasonCode)
                {
                    retVal.NewPaymentStatus    = context.Payment.PaymentStatus = PaymentStatus.Voided;
                    context.Payment.VoidedDate = context.Payment.CancelledDate = DateTime.UtcNow;
                    retVal.IsSuccess           = true;
                }
                else
                {
                    throw new NullReferenceException(string.Format("result from cyber source, not success, decision is {0}, reasonCode is {1}", decision, reasonCode));
                }
            }
            else
            {
                throw new NullReferenceException("no reply from cyber source");
            }

            return(retVal);
        }
        public override VoidProcessPaymentResult VoidProcessPayment(VoidProcessPaymentEvaluationContext context)
        {
            if (context.Payment == null)
            {
                throw new ArgumentNullException("context.Payment is null");
            }

            VoidProcessPaymentResult retVal = new VoidProcessPaymentResult();

            if (!context.Payment.IsApproved && context.Payment.PaymentStatus == PaymentStatus.Authorized)
            {
                try
                {
                    var config         = GetConfigMap();
                    var service        = new PayPalAPIInterfaceServiceService(config);
                    var doVoidResponse = service.DoVoid(new DoVoidReq {
                        DoVoidRequest = new DoVoidRequestType {
                            AuthorizationID = context.Payment.OuterId, Note = "Cancel payment"
                        }
                    });

                    CheckResponse(doVoidResponse);

                    if (context.Payment.OuterId == doVoidResponse.AuthorizationID)
                    {
                        retVal.NewPaymentStatus     = context.Payment.PaymentStatus = PaymentStatus.Voided;
                        context.Payment.VoidedDate  = context.Payment.CancelledDate = DateTime.UtcNow;
                        context.Payment.IsCancelled = true;
                        retVal.IsSuccess            = true;
                    }
                }
                catch (Exception ex)
                {
                    retVal.ErrorMessage = ex.Message;
                }
            }

            return(retVal);
        }
        public void VoidPayment()
        {
            var service = GetCustomerOrderService();
            var order   = service.GetById("ec2b8124-f061-4997-baa1-ca55c1149a58", CustomerOrderResponseGroup.Full);
            var method  = GetMethod();

            var context = new VoidProcessPaymentEvaluationContext
            {
                Payment = order.InPayments.First()
            };

            var result = method.VoidProcessPayment(context);

            service = GetCustomerOrderService();
            service.Update(new CustomerOrder[] { order });

            service = GetCustomerOrderService();
            order   = service.GetById("ec2b8124-f061-4997-baa1-ca55c1149a58", CustomerOrderResponseGroup.Full);

            Assert.AreEqual(PaymentStatus.Voided, order.InPayments.First().PaymentStatus);
            Assert.IsTrue(!order.InPayments.First().IsApproved);
            Assert.IsNotNull(order.InPayments.First().VoidedDate);
        }
Example #7
0
        public void VoidPayment()
        {
            var service = GetCustomerOrderService();
            var order   = service.GetById("161a7df0-a90f-4beb-a23a-9b043f3e5bcb", CustomerOrderResponseGroup.Full);
            var method  = GetMethod();

            var context = new VoidProcessPaymentEvaluationContext
            {
                Payment = order.InPayments.First()
            };

            var result = method.VoidProcessPayment(context);

            service = GetCustomerOrderService();
            service.Update(new CustomerOrder[] { order });

            service = GetCustomerOrderService();
            order   = service.GetById("161a7df0-a90f-4beb-a23a-9b043f3e5bcb", CustomerOrderResponseGroup.Full);

            Assert.AreEqual(PaymentStatus.Voided, order.InPayments.First().PaymentStatus);
            Assert.IsTrue(!order.InPayments.First().IsApproved);
            Assert.IsNotNull(order.InPayments.First().VoidedDate);
        }
Example #8
0
 public override VoidProcessPaymentResult VoidProcessPayment(VoidProcessPaymentEvaluationContext context)
 {
     throw new NotImplementedException();
 }
Example #9
0
        public override VoidProcessPaymentResult VoidProcessPayment(VoidProcessPaymentEvaluationContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }
            if (context.Payment == null)
            {
                throw new ArgumentNullException("context.Payment");
            }

            var retVal = new VoidProcessPaymentResult();

            if (!context.Payment.IsApproved && (context.Payment.PaymentStatus == PaymentStatus.Authorized || context.Payment.PaymentStatus == PaymentStatus.Cancelled))
            {
                if (ApiConnector == null)
                {
                    ApiConnector = Connector.Create(AppSecret, CheckoutBaseUri);
                }

                var connector = ApiConnector;
                var order     = new Order(connector, context.Payment.OuterId);
                order.Fetch();

                var reservation = order.GetValue("reservation") as string;
                if (!string.IsNullOrEmpty(reservation))
                {
                    try
                    {
                        if (KlarnaApi == null)
                        {
                            InitializeKlarnaApi();
                        }

                        var result = KlarnaApi.CancelReservation(reservation);
                        if (result)
                        {
                            retVal.NewPaymentStatus     = context.Payment.PaymentStatus = PaymentStatus.Voided;
                            context.Payment.VoidedDate  = context.Payment.CancelledDate = DateTime.UtcNow;
                            context.Payment.IsCancelled = true;
                            retVal.IsSuccess            = true;
                        }
                        else
                        {
                            retVal.ErrorMessage = "Payment was not canceled, try later";
                        }
                    }
                    catch (Exception ex)
                    {
                        retVal.ErrorMessage = ex.Message;
                    }
                }
            }
            else if (context.Payment.IsApproved)
            {
                retVal.ErrorMessage     = "Payment already approved, use refund";
                retVal.NewPaymentStatus = PaymentStatus.Paid;
            }
            else if (context.Payment.IsCancelled)
            {
                retVal.ErrorMessage     = "Payment already canceled";
                retVal.NewPaymentStatus = PaymentStatus.Voided;
            }

            return(retVal);
        }
Example #10
0
 /// <summary>
 /// Voids the payment
 /// </summary>
 /// <param name="context"></param>
 /// <returns>Result of voiding payment in external payment system</returns>
 public abstract VoidProcessPaymentResult VoidProcessPayment(VoidProcessPaymentEvaluationContext context);
        public override VoidProcessPaymentResult VoidProcessPayment(VoidProcessPaymentEvaluationContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }
            if (context.Payment == null)
            {
                throw new ArgumentNullException("context.Payment");
            }

            var retVal = new VoidProcessPaymentResult();

            if (!context.Payment.IsApproved && (context.Payment.PaymentStatus == PaymentStatus.Authorized || context.Payment.PaymentStatus == PaymentStatus.Cancelled))
            {
                Uri   resourceUri = new Uri(string.Format("{0}/{1}", _euroTestBaseUrl, context.Payment.OuterId));
                var   connector   = Connector.Create(AppSecret);
                Order order       = new Order(connector, resourceUri)
                {
                    ContentType = _contentType
                };
                order.Fetch();

                var reservation = order.GetValue("reservation") as string;
                if (!string.IsNullOrEmpty(reservation))
                {
                    try
                    {
                        Configuration configuration = new Configuration(Country.Code.SE, Language.Code.SV, Currency.Code.SEK, Encoding.Sweden)
                        {
                            Eid        = Convert.ToInt32(AppKey),
                            Secret     = AppSecret,
                            IsLiveMode = false
                        };
                        Api.Api api    = new Api.Api(configuration);
                        var     result = api.CancelReservation(reservation);
                        if (result)
                        {
                            retVal.NewPaymentStatus     = context.Payment.PaymentStatus = PaymentStatus.Voided;
                            context.Payment.VoidedDate  = context.Payment.CancelledDate = DateTime.UtcNow;
                            context.Payment.IsCancelled = true;
                            retVal.IsSuccess            = true;
                        }
                        else
                        {
                            retVal.ErrorMessage = "Payment was not canceled, try later";
                        }
                    }
                    catch (Exception ex)
                    {
                        retVal.ErrorMessage = ex.Message;
                    }
                }
            }
            else if (context.Payment.IsApproved)
            {
                retVal.ErrorMessage     = "Payment already approved, use refund";
                retVal.NewPaymentStatus = PaymentStatus.Paid;
            }
            else if (context.Payment.IsCancelled)
            {
                retVal.ErrorMessage     = "Payment already canceled";
                retVal.NewPaymentStatus = PaymentStatus.Voided;
            }

            return(retVal);
        }
 public override VoidProcessPaymentResult VoidProcessPayment(VoidProcessPaymentEvaluationContext context)
 {
     return(new VoidProcessPaymentResult {
         IsSuccess = false, NewPaymentStatus = PaymentStatus.Voided
     });
 }