smartpay 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7b7941ccf3a44139633152fbb1ec945e3fa8687889b370fa039cbe9a28ec54fd
-  data.tar.gz: 4c823a7e41688255cc6d81289658e183da4b2a9d9d85a340e668dd11b7118309
+  metadata.gz: f015233da3625d9cb3178fb715f7885d9cd0680816dbb368a0ed4ab530577a37
+  data.tar.gz: 98909c98c67fd90c2bb66862edb643f54680b236bdb027e8f6ae6bf3fdd11e77
 SHA512:
-  metadata.gz: b25f291898db670b7e164f64e9d4e37b3bfbf490f69b89896cb763d5cb6f8300bb2adcaf05de6226a37f57130765caf0808ff44d043a4afa19c50de3533ba214
-  data.tar.gz: 0fe3d4a49422422f9ebef68453b8bfdc8ca2b4ca45f3c55b349f74575c12b221ea9b4421e6f1b96555ffc919f389cb4053739964ceab18f516d4267e8f322b0f
+  metadata.gz: 556f127ac1e15bec24476e88d2dfaa47918d19818ce24c3a208ee2e6d0a1a367e6f4a97613060d855358414c55980f446d5ef924c06fac50e2912ed69e39da0b
+  data.tar.gz: d5c98640761e4ae80d39520d8b9d8b97864cc13ab3e50fbcea6bee56f794331c610012e4aff41d6aff20bf65013387719e1db306b0784db09471d445db369738

data/lib/smartpay/api.rb

@@ -3,23 +3,23 @@
 module Smartpay
   class Api
     class << self
-      def create_checkout_session(payload)
-        return create_checkout_session_for_token(payload) if payload[:mode] == "token"
+      def create_checkout_session(payload, idempotency_key: nil)
+        return create_checkout_session_for_token(payload, idempotency_key: idempotency_key) if payload[:mode] == "token"
 
         Responses::CheckoutSession.new(
-          Client.post("/checkout-sessions", params: {}, payload: Requests::CheckoutSession.new(payload).as_hash)
+          Client.post("/checkout-sessions", params: {}, payload: Requests::CheckoutSession.new(payload).as_hash, idempotency_key: idempotency_key)
         )
       end
 
-      def create_checkout_session_for_token(payload)
+      def create_checkout_session_for_token(payload, idempotency_key: nil)
         Responses::CheckoutSession.new(
-          Client.post("/checkout-sessions", params: {}, payload: Requests::CheckoutSessionForToken.new(payload).as_hash)
+          Client.post("/checkout-sessions", params: {}, payload: Requests::CheckoutSessionForToken.new(payload).as_hash, idempotency_key: idempotency_key)
         )
       end
 
-      def create_order(payload)
+      def create_order(payload, idempotency_key: nil)
         Responses::Base.new(
-          Client.post("/orders", params:{}, payload: Requests::Order.new(payload).as_hash)
+          Client.post("/orders", params:{}, payload: Requests::Order.new(payload).as_hash, idempotency_key: idempotency_key)
         )
       end
 
@@ -31,34 +31,34 @@ module Smartpay
         Responses::Base.new(Client.get("/orders/%s" % id, params: { expand: expand }))
       end
 
-      def cancel_order(id)
+      def cancel_order(id, idempotency_key: nil)
         Responses::Base.new(
-          Client.put("/orders/%s/cancellation" % id)
+          Client.put("/orders/%s/cancellation" % id, idempotency_key: idempotency_key)
         )
       end
 
-      def create_payment(payload)
+      def create_payment(payload, idempotency_key: nil)
         Responses::Base.new(
-          Client.post("/payments", params:{}, payload: Requests::Payment.new(payload).as_hash)
+          Client.post("/payments", params:{}, payload: Requests::Payment.new(payload).as_hash, idempotency_key: idempotency_key)
         )
       end
 
-      def capture(payload)
-        create_payment(payload)
+      def capture(payload, idempotency_key: nil)
+        create_payment(payload, idempotency_key: idempotency_key)
       end
 
       def get_payment(id, expand: '' )
         Responses::Base.new(Client.get("/payments/%s" % id, params: { expand: expand }))
       end
 
-      def create_refund(payload)
+      def create_refund(payload, idempotency_key: nil)
         Responses::Base.new(
-          Client.post("/refunds", params:{}, payload: Requests::Refund.new(payload).as_hash)
+          Client.post("/refunds", params:{}, payload: Requests::Refund.new(payload).as_hash, idempotency_key: idempotency_key)
         )
       end
 
-      def refund(payload)
-        create_refund(payload)
+      def refund(payload, idempotency_key: nil)
+        create_refund(payload, idempotency_key: idempotency_key)
       end
 
       def get_refund(id, expand: '' )
@@ -73,16 +73,16 @@ module Smartpay
         Responses::Base.new(Client.get("/tokens/%s" % id))
       end
 
-      def enable_token(id)
-        Responses::Base.new(Client.put("/tokens/%s/enable" % id))
+      def enable_token(id, idempotency_key: nil)
+        Responses::Base.new(Client.put("/tokens/%s/enable" % id, idempotency_key: idempotency_key))
       end
 
-      def disable_token(id)
-        Responses::Base.new(Client.put("/tokens/%s/disable" % id))
+      def disable_token(id, idempotency_key: nil)
+        Responses::Base.new(Client.put("/tokens/%s/disable" % id, idempotency_key: idempotency_key))
       end
 
-      def delete_token(id)
-        Responses::Base.new(Client.delete("/tokens/%s" % id))
+      def delete_token(id, idempotency_key: nil)
+        Responses::Base.new(Client.delete("/tokens/%s" % id, idempotency_key: idempotency_key))
       end
     end
   end

data/lib/smartpay/client.rb

@@ -9,45 +9,57 @@ module Smartpay
     class << self
       def get(path, params: {})
         request_params = default_params.merge(params)
-        RestClient::Request.execute(method: :get, url: api_url(path),
-                                               headers: headers.merge(params: request_params),
-                                               timeout: timeout)
+        with_retries(retry_options) do
+          RestClient::Request.execute(
+            method: :get,
+            url: api_url(path),
+            headers: headers.merge(params: request_params),
+            timeout: timeout
+          )
+        end
       end
 
-      def post(path, params: {}, payload: {})
+
+      def post(path, params: {}, payload: {}, idempotency_key: nil)
         request_params = default_params.merge(params)
         request_payload = default_payload.merge(payload)
-        idempotency_key = nonce
-        with_retries(:max_tries => 1, :rescue => [RestClient::BadRequest, RestClient::BadGateway, RestClient::ServiceUnavailable, RestClient::GatewayTimeout]) do
-          RestClient::Request.execute(method: :post, url: api_url(path),
-                                                params: request_params,
-                                                headers: headers.merge({Idempotency_Key: idempotency_key}).merge(params: request_params),
-                                                timeout: timeout,
-                                                payload: request_payload.to_json)
+        idempotency_key ||= nonce
+        with_retries(retry_options) do
+          RestClient::Request.execute(
+            method: :post,
+            url: api_url(path),
+            headers: headers.merge({ Idempotency_Key: idempotency_key }).merge(params: request_params),
+            timeout: timeout,
+            payload: request_payload.to_json
+          )
         end
       end
 
-      def put(path, params: {}, payload: {})
-        request_params = default_params.merge(params).merge({'Idempotency-Key': nonce})
+      def put(path, params: {}, payload: {}, idempotency_key: nil)
+        request_params = default_params.merge(params)
         request_payload = default_payload.merge(payload)
-        idempotency_key = nonce
-        with_retries(:max_tries => 1, :rescue => [RestClient::InternalServerError, RestClient::BadGateway, RestClient::ServiceUnavailable, RestClient::GatewayTimeout]) do
-          RestClient::Request.execute(method: :put, url: api_url(path),
-                                                params: request_params,
-                                                headers: headers.merge({Idempotency_Key: idempotency_key}).merge(params: request_params),
-                                                timeout: timeout,
-                                                payload: request_payload.to_json)
+        idempotency_key ||= nonce
+        with_retries(retry_options) do
+          RestClient::Request.execute(
+            method: :put,
+            url: api_url(path),
+            headers: headers.merge({ Idempotency_Key: idempotency_key }).merge(params: request_params),
+            timeout: timeout,
+            payload: request_payload.to_json
+          )
         end
       end
 
-      def delete(path, params: {})
-        request_params = default_params.merge(params).merge({'Idempotency-Key': nonce})
-        idempotency_key = nonce
-        with_retries(:max_tries => 1, :rescue => [RestClient::InternalServerError, RestClient::BadGateway, RestClient::ServiceUnavailable, RestClient::GatewayTimeout]) do
-          RestClient::Request.execute(method: :delete, url: api_url(path),
-                                                params: request_params,
-                                                headers: headers.merge({Idempotency_Key: idempotency_key}).merge(params: request_params),
-                                                timeout: timeout)
+      def delete(path, params: {}, idempotency_key: nil)
+        request_params = default_params.merge(params)
+        idempotency_key ||= nonce
+        with_retries(retry_options) do
+          RestClient::Request.execute(
+            method: :delete,
+            url: api_url(path),
+            headers: headers.merge({ Idempotency_Key: idempotency_key }).merge(params: request_params),
+            timeout: timeout
+          )
         end
       end
 
@@ -62,7 +74,7 @@ module Smartpay
       end
 
       def timeout
-        Smartpay.configuration.post_timeout
+        Smartpay.configuration.request_timeout
       end
 
       def headers
@@ -84,6 +96,10 @@ module Smartpay
         }.freeze
       end
 
+      def retry_options
+        Smartpay.configuration.retry_options
+      end
+
       def default_payload
         {}.freeze
       end

data/lib/smartpay/configuration.rb

@@ -1,16 +1,25 @@
 # frozen_string_literal: true
 
+require "rest-client"
+
 module Smartpay
   class Configuration
     attr_accessor :public_key, :secret_key
-    attr_writer :post_timeout, :api_url, :checkout_url
+    attr_writer :request_timeout, :api_url, :checkout_url, :retry_options
 
     DEFAULT_TIMEOUT_SETTING = 30
     DEFAULT_API_URL = "https://api.smartpay.co/v1"
     DEFAULT_CHECKOUT_URL = "https://checkout.smartpay.co"
+    DEFAULT_RETRY_OPTIONS = {
+      max_tries: 1,
+      base_sleep_seconds: 0.5,
+      max_sleep_seconds: 1.0,
+      rescue: [RestClient::InternalServerError,RestClient::BadGateway,
+               RestClient::ServiceUnavailable, RestClient::GatewayTimeout]
+    }.freeze
 
     def initialize
-      @post_timeout = DEFAULT_TIMEOUT_SETTING
+      @request_timeout = DEFAULT_TIMEOUT_SETTING
       @api_url = if in_development_mode?
                    ENV["SMARTPAY_API_PREFIX"].downcase || DEFAULT_API_URL
                  else
@@ -21,10 +30,11 @@ module Smartpay
                       else
                         DEFAULT_CHECKOUT_URL
                       end
+      @retry_options = DEFAULT_RETRY_OPTIONS
     end
 
-    def post_timeout
-      @post_timeout || DEFAULT_TIMEOUT_SETTING
+    def request_timeout
+      @request_timeout || DEFAULT_TIMEOUT_SETTING
     end
 
     def api_url
@@ -39,6 +49,10 @@ module Smartpay
       @checkout_url || DEFAULT_CHECKOUT_URL
     end
 
+    def retry_options
+      @retry_options || DEFAULT_RETRY_OPTIONS
+    end
+
     private
 
     def in_development_mode?

data/lib/smartpay/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Smartpay
-  VERSION = "0.7.0"
+  VERSION = "0.8.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: smartpay
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Smartpay
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-01-10 00:00:00.000000000 Z
+date: 2023-01-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client