Пример #1
0
        public ActionResult Destroy(string id)
        {
            var orderId = new Guid(id);
            var order   = MvcApplication.FindOrder(orderId);

            if (order == null)
            {
                return(Redirect("/"));
            }

            //this is a return, or a Void
            //just need the transaction ID
            var gate = OpenGateway();

            //void it
            var request  = new VoidRequest(order.TransactionID);
            var response = gate.Send(request);

            if (response.Approved)
            {
                order.AuthCode     = response.AuthorizationCode;
                order.OrderMessage = "Your order was refunded - we've put a fresh pot on";

                //reset it
                Session["order"] = order;
            }
            else
            {
                //error... oops. Reload the page
                order.OrderMessage = response.Message;
            }

            //record the order, send to the receipt page
            return(View());
        }
Пример #2
0
        public async void Run_SimpleVoidTest()
        {
            ShowTestOnTerminal("SimpleVoid");

            AuthorizationRequest setupRequest = new AuthorizationRequest
            {
                Pan            = "4111111111111111",
                ExpMonth       = "12",
                ExpYear        = "2025",
                Amount         = "25.55",
                Test           = true,
                TransactionRef = Guid.NewGuid().ToString("N"),
            };

            output.WriteLine("Setup request: {0}", setupRequest);

            AuthorizationResponse setupResponse = await blockchyp.ChargeAsync(setupRequest);

            output.WriteLine("Setup Response: {0}", setupResponse);

            VoidRequest request = new VoidRequest
            {
                TransactionId = setupResponse.TransactionId,
                Test          = true,
            };

            output.WriteLine("Request: {0}", request);

            VoidResponse response = await blockchyp.VoidAsync(request);

            output.WriteLine("Response: {0}", response);

            Assert.True(response.Success, "response.Success");
            Assert.True(response.Approved, "response.Approved");
        }
Пример #3
0
        protected void btnReturn_Click(object sender, EventArgs e)
        {
            var order = (CoffeeShopWebApp.Model.CoffeeOrder)Session["order"];

            if (order == null)
            {
                Response.Redirect("/");
            }

            //this is a return, or a Void
            //just need the transaction ID
            var gate = OpenGateway();

            //void it
            var request  = new VoidRequest(order.TransactionID);
            var response = gate.Send(request);

            if (response.Approved)
            {
                order.AuthCode     = response.AuthorizationCode;
                order.OrderMessage = "Your order was refunded - we've put a fresh pot on";

                //reset it
                Session["order"] = order;
                lblOrder.Text    = order.OrderMessage;
            }
            else
            {
                //error... oops. Reload the page
                order.OrderMessage = response.Message;
            }
        }
Пример #4
0
        public Task <VoidResponse> VoidTransactionAsync(VoidRequest voidRequest)
        {
            var request = new RestRequest(Urls.TransactionsApiV1Void, Method.POST);

            request.AddJsonBody(voidRequest);
            return(MakeRestRequest <VoidResponse>(request));
        }
Пример #5
0
        // Void
        public async Task <VoidResponse> Void(VoidRequest req)
        {
            string jsonRequest  = CommonService.JsonSerializer <VoidRequest>(req);
            string jsonResponse = await PostRequest(jsonRequest, "authorize", req.TransactionID);

            return(CommonService.JsonDeSerializer <VoidResponse>(jsonResponse));
        }
        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);
        }
Пример #7
0
        public RepositoryInfo[] getAllRepositories([System.Xml.Serialization.XmlElementAttribute("GetAllRepositories", Namespace = "http://www.informatica.com/wsh", IsNullable = true)] VoidRequest GetAllRepositories1)
        {
            object[] results = this.Invoke("getAllRepositories", new object[] {
                GetAllRepositories1
            });

            return((RepositoryInfo[])(results[0]));
        }
Пример #8
0
        public VoidResponse logout([System.Xml.Serialization.XmlElementAttribute("Logout", Namespace = "http://www.informatica.com/wsh")] VoidRequest Logout1)
        {
            object[] results = this.Invoke("logout", new object[] {
                Logout1
            });

            return((VoidResponse)(results[0]));
        }
Пример #9
0
 public Task <VoidResponse> VoidPayment(string paymentId, VoidRequest voidRequest,
                                        CancellationToken cancellationToken = default)
 {
     CheckoutUtils.ValidateParams("paymentId", paymentId, "voidRequest", voidRequest);
     return(ApiClient.Post <VoidResponse>(
                BuildPath(GetBaseUrl(), OrdersPath, paymentId, VoidsPath),
                SdkAuthorization(),
                voidRequest,
                cancellationToken));
 }
Пример #10
0
 /// <remarks/>
 public void getAllRepositoriesAsync(VoidRequest GetAllRepositories1, object userState)
 {
     if ((this.getAllRepositoriesOperationCompleted == null))
     {
         this.getAllRepositoriesOperationCompleted = new System.Threading.SendOrPostCallback(this.OngetAllRepositoriesOperationCompleted);
     }
     this.InvokeAsync("getAllRepositories", new object[] {
         GetAllRepositories1
     }, this.getAllRepositoriesOperationCompleted, userState);
 }
Пример #11
0
        private static async Task <VoidResponse> VoidSaleAsync(string paymentId, IPagadorClient client)
        {
            var request = new VoidRequest
            {
                Amount    = 100000,
                PaymentId = paymentId
            };

            return(await client.VoidAsync(request));
        }
Пример #12
0
 /// <remarks/>
 public void logoutAsync(VoidRequest Logout1, object userState)
 {
     if ((this.logoutOperationCompleted == null))
     {
         this.logoutOperationCompleted = new System.Threading.SendOrPostCallback(this.OnlogoutOperationCompleted);
     }
     this.InvokeAsync("logout", new object[] {
         Logout1
     }, this.logoutOperationCompleted, userState);
 }
        public async Task <VoidResponse> VoidAsync(VoidRequest request, MerchantCredentials credentials = null)
        {
            if (request == null)
            {
                throw new ArgumentNullException(nameof(request));
            }

            if (_credentials == null && credentials == null)
            {
                throw new InvalidOperationException("Credentials are null");
            }

            var currentCredentials = credentials ?? _credentials;

            if (string.IsNullOrWhiteSpace(currentCredentials.MerchantId))
            {
                throw new InvalidOperationException("Invalid credentials: MerchantId is null");
            }

            if (string.IsNullOrWhiteSpace(currentCredentials.MerchantKey))
            {
                throw new InvalidOperationException("Invalid credentials: MerchantKey is null");
            }

            var httpRequest = new RestRequest(@"v2/sales/{paymentId}/void", Method.PUT)
            {
                RequestFormat = DataFormat.Json
            };

            httpRequest.AddHeader("Content-Type", "application/json");
            httpRequest.AddHeader("MerchantId", currentCredentials.MerchantId);
            httpRequest.AddHeader("MerchantKey", currentCredentials.MerchantKey);
            httpRequest.AddHeader("RequestId", Guid.NewGuid().ToString());
            httpRequest.AddUrlSegment("paymentId", request.PaymentId);
            httpRequest.AddQueryParameter("amount", request.Amount.ToString(CultureInfo.InvariantCulture));

            var cancellationTokenSource = new CancellationTokenSource();

            var httpResponse = await RestClientApi.ExecuteTaskAsync(httpRequest, cancellationTokenSource.Token);

            if (httpResponse.StatusCode != HttpStatusCode.OK)
            {
                return(new VoidResponse
                {
                    HttpStatus = httpResponse.StatusCode,
                    ErrorDataCollection = JsonDeserializer.Deserialize <List <ErrorData> >(httpResponse)
                });
            }

            var jsonResponse = JsonDeserializer.Deserialize <VoidResponse>(httpResponse);

            jsonResponse.HttpStatus = httpResponse.StatusCode;
            return(jsonResponse);
        }
Пример #14
0
        public async Task VoidCompletes_Test()
        {
            var authorization = new AuthorizeRequest
            {
                Amount = new Amount
                {
                    BaseAmount = 1000
                },
                Card = new Card
                {
                    CardPresent     = false,
                    Cvv             = "123",
                    ExpirationMonth = "12",
                    ExpirationYear  = "21",
                    Pan             = "5105105105105100"
                },
                Mid      = _merchantId,
                Terminal = new Terminal
                {
                    EntryType    = EntryType.Keypad,
                    TerminalId   = _terminalId,
                    TerminalType = TerminalType.ECommerce
                },
                Payer = new Payer
                {
                    BillingAddress = new Address
                    {
                        PostalCode = "76132"
                    }
                }
            };

            var response = await _client.AuthorizeAmountAsync(authorization);

            Assert.IsNotNull(response.TransactionId);
            Assert.IsNotNull(response.AuthCode);

            var voidRequest = new VoidRequest
            {
                Mid      = _merchantId,
                Terminal = new Terminal
                {
                    EntryType    = EntryType.Keypad,
                    TerminalId   = _terminalId,
                    TerminalType = TerminalType.ECommerce
                },
                TransactionId = response.TransactionId
            };

            var voidResponse = await _client.VoidTransactionAsync(voidRequest);

            Assert.IsNotNull(voidResponse.TransactionId);
        }
Пример #15
0
 public Task <VoidResponse> VoidPayment(
     string paymentId,
     VoidRequest voidRequest             = null,
     string idempotencyKey               = null,
     CancellationToken cancellationToken = default)
 {
     CheckoutUtils.ValidateParams("paymentId", paymentId);
     return(ApiClient.Post <VoidResponse>(BuildPath(PaymentsPath, paymentId, "voids"),
                                          SdkAuthorization(),
                                          voidRequest,
                                          cancellationToken,
                                          idempotencyKey));
 }
        private TransactionResponse Void(string reference)
        {
            var voidRequest = new VoidRequest(_userName, _password, reference);
            var response    = voidRequest.Execute();

            return(new TransactionResponse
            {
                Approved = response.ResponseStatus == ResponseStatus.Approved,
                AuthCode = response.AuthCode,
                Message = response.ResponseText,
                TransactionId = response.TransactionId
            });
        }
Пример #17
0
        private TransactionResponse VoidRequest(string reference)
        {
            var req      = new VoidRequest(reference);
            var response = Gateway.Send(req);

            return(new TransactionResponse
            {
                Approved = response.Approved,
                AuthCode = response.AuthorizationCode,
                Message = response.Message,
                TransactionId = response.TransactionID
            });
        }
Пример #18
0
        public async Task <IActionResult> Void(VoidRequest request)
        {
            TransactionOutput serviceResponse = await _service.VoidTransaction(request.AuthorizationId);

            StatusResponse response = new StatusResponse
            {
                AmountAvailable = serviceResponse.AmountAvailable,
                Currency        = serviceResponse.Currency,
                Error           = serviceResponse.Error,
                Success         = serviceResponse.Success
            };

            return(Ok(response));
        }
Пример #19
0
        private async Task ShouldVoidCardPayment()
        {
            var paymentResponse = await MakeCardPayment();

            var voidRequest = new VoidRequest {
                Reference = Guid.NewGuid().ToString()
            };

            var response = await PreviousApi.PaymentsClient().VoidPayment(paymentResponse.Id, voidRequest);

            response.ShouldNotBeNull();
            response.ActionId.ShouldNotBeNullOrEmpty();
            response.Reference.ShouldNotBeNullOrEmpty();
            response.GetLink("payment").ShouldNotBeNull();
        }
Пример #20
0
        private async Task ShouldVoidPayment_Request()
        {
            var voidRequest  = new VoidRequest();
            var voidResponse = new VoidResponse();

            _apiClient.Setup(apiClient =>
                             apiClient.Post <VoidResponse>(PaymentsPath + "/payment_id/voids", _authorization,
                                                           voidRequest,
                                                           CancellationToken.None, "test"))
            .ReturnsAsync(() => voidResponse);

            IPaymentsClient paymentsClient = new PaymentsClient(_apiClient.Object, _configuration.Object);

            var response = await paymentsClient.VoidPayment("payment_id", voidRequest, "test");

            response.ShouldNotBeNull();
        }
        public async Task CanVoidPayment()
        {
            var paymentRequest  = TestHelper.CreateCardPaymentRequest();
            var paymentResponse = await _api.Payments.RequestAsync(paymentRequest);

            paymentResponse.Payment.CanVoid().ShouldBe(true);

            var voidRequest = new VoidRequest
            {
                Reference = Guid.NewGuid().ToString()
            };

            var voidResponse = await _api.Payments.VoidAsync(paymentResponse.Payment.Id, voidRequest);

            voidResponse.ActionId.ShouldNotBeNullOrEmpty();
            voidResponse.Reference.ShouldBe(voidRequest.Reference);
        }
Пример #22
0
        private async Task ShouldVoidPayment()
        {
            var voidRequest  = new VoidRequest();
            var voidResponse = new VoidResponse();

            _apiClient.Setup(apiClient =>
                             apiClient.Post <VoidResponse>("klarna-external/orders/id/voids", _authorization,
                                                           voidRequest,
                                                           CancellationToken.None, null))
            .ReturnsAsync(() => voidResponse);

            var klarnaClient = new KlarnaClient(_apiClient.Object, _configuration.Object);

            var response = await klarnaClient.VoidPayment("id", voidRequest, CancellationToken.None);

            response.ShouldNotBeNull();
        }
Пример #23
0
        public override async Task GetTodos(VoidRequest request, IServerStreamWriter <TodoReturn> responseStream, ServerCallContext context)
        {
            List <TodoReturn> listTodo = new List <TodoReturn>();

            var result = await _toporepository.GetAllTodos();

            foreach (var item in result)
            {
                listTodo.Add(new TodoReturn
                {
                    Category = item.Category,
                    Content  = item.Content,
                    Title    = item.Title
                });
            }
            foreach (var item in listTodo)
            {
                await responseStream.WriteAsync(item);
            }
        }
Пример #24
0
        private async Task ShouldVoidCardPaymentIdempotently()
        {
            var paymentResponse = await MakeCardPayment();

            var voidRequest = new VoidRequest {
                Reference = Guid.NewGuid().ToString()
            };

            var response = await Retriable(async() =>
                                           await PreviousApi.PaymentsClient()
                                           .VoidPayment(paymentResponse.Id, voidRequest, IdempotencyKey));

            response.ShouldNotBeNull();

            var response2 = await Retriable(async() =>
                                            await PreviousApi.PaymentsClient()
                                            .VoidPayment(paymentResponse.Id, voidRequest, IdempotencyKey));

            response2.ShouldNotBeNull();

            response.ActionId.ShouldBe(response2.ActionId);
        }
Пример #25
0
        /// <summary>
        /// Successful response returned from a Void Transaction request.
        /// https://apidocs.securenet.com/docs/voids.html?lang=csharp
        /// </summary>
        public void Voids_Void_Transaction_Request_Returns_Successfully(int transactionId)
        {
            // Arrange
            var request = new VoidRequest
            {
                TransactionId        = transactionId,
                DeveloperApplication = new DeveloperApplication
                {
                    DeveloperId = 12345678,
                    Version     = "1.2"
                }
            };

            var apiContext = new APIContext();
            var controller = new PaymentsController();

            // Act
            var response = controller.ProcessRequest <VoidResponse>(apiContext, request);

            // Assert
            Assert.IsNotNull(response);
            Assert.IsTrue(response.Success);
        }
Пример #26
0
        public override Task <CustomerListBookResponse> GetAllBooks(VoidRequest request, ServerCallContext context)
        {
            logger.LogInformation("Begin grpc call from method {Method} for all books", context.Method);
            //using ( var dbcontext = new dbBooksContext(dbContextOptions))
            //{
            CustomerListBookResponse response = new CustomerListBookResponse();
            var datas = bookContext.Books;

            foreach (var item in datas)
            {
                response.Books.Add(new CustomerBookDataReponse
                {
                    Id       = item.Id,
                    Name     = item.Name,
                    Price    = item.Price,
                    Category = item.Category,
                    Author   = item.Author,
                });
            }

            return(Task.FromResult(response));

            //}
        }
        //////////////// Void methods /////////////
        private void VoidButton_Click(object sender, EventArgs e)
        {
            VoidRequest request = new VoidRequest();
            if (OrderPaymentsView.SelectedItems.Count == 1)
            {
                POSPayment payment = ((POSPayment)OrderPaymentsView.SelectedItems[0].Tag);
                request.PaymentId = payment.PaymentID;
                request.EmployeeId = payment.EmployeeID;
                request.OrderId = payment.OrderID;
                request.VoidReason = "USER_CANCEL";

                cloverConnector.VoidTransaction(request);
            }
        }
Пример #28
0
        public VoidResponse Void(Guid paymentId, MerchantAuthentication merchantAuthentication, VoidRequest voidRequest)
        {
            var restRequest = new RestRequest(@"sales/{paymentId}/void", Method.PUT)
            {
                RequestFormat = DataFormat.Json
            };

            AddHeaders(restRequest, merchantAuthentication);

            restRequest.AddUrlSegment("paymentId", paymentId.ToString());

            if (voidRequest.Amount != null)
            {
                restRequest.AddQueryParameter("amount", voidRequest.Amount.ToString());
            }

            var response = RestClient.Execute <VoidResponse>(restRequest);


            VoidResponse voidResponse = null;

            if (response.StatusCode == HttpStatusCode.OK)
            {
                voidResponse = JsonConvert.DeserializeObject <VoidResponse>(response.Content);
            }
            else if (response.StatusCode == HttpStatusCode.BadRequest)
            {
                voidResponse = new VoidResponse {
                    ErrorDataCollection = JsonDeserializer.Deserialize <List <Error> >(response)
                }
            }
            ;
            else
            {
                voidResponse = new VoidResponse();
            }

            voidResponse.HttpStatus = response.StatusCode;

            return(voidResponse);
        }
Пример #29
0
        public override bool ProcessPayment(Payment payment, ref string message)
        {
            var info = payment as CreditCardPayment;

            if (ReferenceEquals(info, null))
            {
                payment.Status = PaymentStatus.Failed.ToString();
                message        = "AuthorizeNet gateway supports only CreditCardPayment";
                return(false);
            }

            string[] validateSettings = { "MerchantLogin", "MerchantPassword" };

            foreach (var validateSetting in validateSettings)
            {
                if (!Settings.ContainsKey(validateSetting) || string.IsNullOrWhiteSpace(Settings[validateSetting]))
                {
                    payment.Status = PaymentStatus.Failed.ToString();
                    message        = string.Format("{0} not configured", validateSetting);
                    return(false);
                }
            }

            var transactionType = (TransactionType)Enum.Parse(typeof(TransactionType), info.TransactionType);

            payment.Status = PaymentStatus.Processing.ToString();

            var gateway = new Gateway(Settings["MerchantLogin"], Settings["MerchantPassword"]);

            bool isTestMode;

            if (Settings.ContainsKey("TestMode") && bool.TryParse(Settings["TestMode"], out isTestMode))
            {
                gateway.TestMode = isTestMode;
            }

            var             description = string.Format("{0} transaction for order id {1}", transactionType, info.OrderForm.OrderGroupId);
            IGatewayRequest request     = null;

            switch (transactionType)
            {
            case TransactionType.Authorization:
            case TransactionType.Sale:
                request = new AuthorizationRequest(info.CreditCardNumber,
                                                   string.Format("{0}{1}", info.CreditCardExpirationMonth, info.CreditCardExpirationYear),
                                                   info.Amount,
                                                   description,
                                                   transactionType == TransactionType.Sale);
                break;

            case TransactionType.Capture:
                request = new PriorAuthCaptureRequest(info.Amount, info.ValidationCode);
                break;

            case TransactionType.Credit:
                request = new CreditRequest(info.ValidationCode, info.Amount, info.CreditCardNumber);
                break;

            case TransactionType.Void:
                request = new VoidRequest(info.ValidationCode);
                break;
            }

            if (request == null)
            {
                payment.Status = PaymentStatus.Failed.ToString();
                message        = string.Format("Unsupported transation type {0}", transactionType);
                return(false);
            }

            request.AddCardCode(info.CreditCardSecurityCode);

            var invoice = info.OrderForm.OrderGroupId;

            var order = info.OrderForm.OrderGroup as Order;

            if (order != null)
            {
                invoice = order.TrackingNumber;
            }

            request.AddInvoice(invoice);
            request.AddTax(info.OrderForm.TaxTotal);

            // Find the address
            var address = info.OrderForm.OrderGroup.OrderAddresses
                          .FirstOrDefault(a => String.Compare(a.OrderAddressId, info.BillingAddressId, StringComparison.OrdinalIgnoreCase) == 0);

            if (address != null)
            {
                request.AddCustomer(address.Email, address.FirstName, address.LastName,
                                    address.Line1 + " " + address.Line2, address.StateProvince, address.PostalCode);
            }

            //foreach (var lineItem in info.OrderForm.LineItems)
            //{
            //    request.AddLineItem(lineItem.LineItemId, lineItem.DisplayName, lineItem.Description,
            //        (int)lineItem.Quantity, lineItem.PlacedPrice, false);
            //}


            try
            {
                var response = gateway.Send(request, description);

                if (!response.Approved)
                {
                    payment.Status = PaymentStatus.Denied.ToString();
                    message        = "Transaction Declined: " + response.Message;
                    return(false);
                }
                info.StatusCode        = response.ResponseCode;
                info.StatusDesc        = response.Message;
                info.ValidationCode    = response.TransactionID;
                info.AuthorizationCode = response.AuthorizationCode;

                // transaction is marked as completed every time the payment operation succeeds even if it is void transaction type
                payment.Status = PaymentStatus.Completed.ToString();
            }
            catch (Exception ex)
            {
                payment.Status = PaymentStatus.Failed.ToString();
                throw new ApplicationException(ex.Message);
            }

            return(true);
        }
			public virtual void StubServiceMethodWithNoResponse(VoidRequest request) { }
Пример #31
0
        public ActionResult StartNewSeason(VoidRequest request)
        {
            var seasonName = _seasonLogic.StartNewSeason();

            return Ok(seasonName);
        }
Пример #32
0
 public ActionResult GetSeasons(VoidRequest request)
 {
     List<Season> seasons = _seasonLogic.GetSeasons();
     return Ok(seasons);
 }