payment_recipes 1.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 66541abdf7844f23ca778f821c3220c2aac9dcbd
-  data.tar.gz: 78b1f94824133cc81cdb4f200e1b6f8f563f7403
+  metadata.gz: 60ecc7638850540116e27e88c520b2b7d2ff8b60
+  data.tar.gz: 1249548f4b18acb1bc8c1b6f29f6efa5aaacf8ab
 SHA512:
-  metadata.gz: 6bef25ec95f76928833bc96aa736a902c6940f37f61cc8be70a24df8e267b351c4fdde341b4402cc8eb33be91f19ab752f57a7e44e8bf0ed8b262fd3c2e9ad58
-  data.tar.gz: bc32138fa4b1630529b75ddb4b98f7abbafa9bfbe8c5660471b2360be6f3c156e5f3900602c40bf5eac4ddb7a2ccc9713d9e70a65161f1bcaed76680fd4ab47b
+  metadata.gz: 36dead83b189551ef563ffbce73c5cb9f92529aab5631decb9a870b2a70508331c1944929568e2d36e385e37941ead13919982327ded5c48e042f0dccbae6c4a
+  data.tar.gz: d3146a05564469ab2786b9ec118f8af9490e8779ee08488daf793f050a9500f05dd43db03a32a145aff3e43bf37a958576b190b0f01a1e878584f1aca6e861d6

data/lib/payment_recipes/paypal/rest/action/capture_authorization.rb

@@ -0,0 +1,27 @@
+module PaymentRecipes
+  module PayPal
+    module REST
+      module Action
+        class CaptureAuthorization < PaymentRecipes::Utils::Action
+          variable :authorization, "PaymentRecipes::PayPal::REST::Authorization"
+
+          def perform
+            if @authorization.can_be_captured?
+              currency = @authorization.currency
+              total = @authorization.total.to_s
+
+              @authorization.raw_authorization.capture({:amount => { :currency => currency, :total => total } })
+
+              @authorization.reload!
+              @authorization.reload_payment!
+            else
+              raise Exception, "Authorization can't be captured"
+            end
+
+            @authorization
+          end
+        end
+      end
+    end
+  end
+end

data/lib/payment_recipes/paypal/rest/action/create_payment.rb

@@ -0,0 +1,73 @@
+module PaymentRecipes
+  module PayPal
+    module REST
+      module Action
+        class CreatePayment < PaymentRecipes::Utils::Action
+          variable :intent, "Symbol"
+          variable :attributes, "Hash"
+          variable :amount, "Money"
+          variable :description, "String"
+
+          include ::PaymentRecipes::Utils::Converters
+
+          def perform
+            unless [:sale, :authorize].include?(intent)
+              raise Exception, "Allowed values for intent: :sale, :authorize"
+            end
+
+            create_paypal_payment!
+            find_payment!
+
+            payment
+          end
+
+          def create_paypal_payment!
+            store(:paypal_payment) do
+              new_paypal_payment = ::PayPal::SDK::REST::Payment.new(payment_attributes)
+              new_paypal_payment.create
+
+              new_paypal_payment
+            end
+          end
+
+          def find_payment!
+            store(:payment) do
+              ::PaymentRecipes::PayPal::REST::Payment.find(paypal_payment.id)
+            end
+          end
+
+          def redirect_url
+            paypal_payment.links.select { |link| link.rel == 'approval_url' }.first.href rescue nil
+          end
+
+          def sale
+            return nil unless payment
+
+            payment.sale
+          end
+
+          def authorization
+            return nil unless payment
+
+            payment.authorization
+          end
+
+          def payment_attributes
+            {
+              "intent" => convert_to_string(intent),
+              "transactions" => [
+                {
+                  "amount" => {
+                    "total" => amount.to_s,
+                    "currency" => amount.currency.iso_code
+                  },
+                  "description" => description
+                }
+              ]
+            }.merge(attributes)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/payment_recipes/paypal/rest/action/execute_payment.rb

@@ -0,0 +1,25 @@
+module PaymentRecipes
+  module PayPal
+    module REST
+      module Action
+        class ExecutePayment < PaymentRecipes::Utils::Action
+          variable :payment, "PaymentRecipes::PayPal::REST::Payment"
+          variable :payer_id, "String"
+
+          def perform
+            @payment.raw_payment.execute( :payer_id => payer_id )
+            @payment.reload!
+
+            @payment
+          end
+
+          def authorization
+            return nil unless payment
+
+            payment.authorization
+          end
+        end
+      end
+    end
+  end
+end

data/lib/payment_recipes/paypal/rest/action/refund_capture.rb

@@ -0,0 +1,24 @@
+module PaymentRecipes
+  module PayPal
+    module REST
+      module Action
+        class RefundCapture < PaymentRecipes::Utils::Action
+          variable :capture, "PaymentRecipes::PayPal::REST::Capture"
+
+          def perform
+            if @capture.can_be_refunded?
+              @capture.raw_capture.refund({})
+
+              @capture.reload!
+              @capture.reload_payment!
+            else
+              raise Exception, "Capture can't be refunded"
+            end
+
+            @capture
+          end
+        end
+      end
+    end
+  end
+end

data/lib/payment_recipes/paypal/rest/action/refund_sale.rb

@@ -0,0 +1,24 @@
+module PaymentRecipes
+  module PayPal
+    module REST
+      module Action
+        class RefundSale < PaymentRecipes::Utils::Action
+          variable :sale, "PaymentRecipes::PayPal::REST::Sale"
+
+          def perform
+            if @sale.can_be_refunded?
+              @sale.raw_sale.refund({})
+
+              @sale.reload!
+              @sale.reload_payment!
+            else
+              raise Exception, "Sale can't be refunded"
+            end
+
+            @sale
+          end
+        end
+      end
+    end
+  end
+end

data/lib/payment_recipes/paypal/rest/action/void_authorization.rb

@@ -0,0 +1,24 @@
+module PaymentRecipes
+  module PayPal
+    module REST
+      module Action
+        class VoidAuthorization < PaymentRecipes::Utils::Action
+          variable :authorization, "PaymentRecipes::PayPal::REST::Authorization"
+
+          def perform
+            if @authorization.can_be_captured?
+              @authorization.raw_authorization.void()
+
+              @authorization.reload!
+              @authorization.reload_payment!
+            else
+              raise Exception, "Authorization can't be voided"
+            end
+
+            @authorization  
+          end
+        end
+      end
+    end
+  end
+end

data/lib/payment_recipes/paypal/rest/authorization.rb

@@ -0,0 +1,172 @@
+module PaymentRecipes
+  module PayPal
+    module REST
+      class Authorization
+        attr_reader :id
+        attr_reader :currency
+        attr_reader :total
+        attr_reader :payment
+        attr_reader :payment_id
+        attr_reader :subtotal
+        attr_reader :state
+        attr_reader :create_time
+        attr_reader :update_time
+        attr_reader :valid_until
+
+        attr_reader :payment_mode
+        attr_reader :protection_eligibility
+        attr_reader :protection_eligibility_type
+
+        attr_reader :expanded
+        attr_reader :raw_authorization
+
+        include ::PaymentRecipes::Utils::Converters
+        include ::PaymentRecipes::Utils::Equality
+
+        def initialize(paypal_authorization, payment: nil, expanded: false)
+          unless paypal_authorization.is_a?(::PayPal::SDK::REST::DataTypes::Authorization)
+            raise Exception, "#{ self.class.name } must be initialized with a PayPal Authorization" 
+          end
+
+          if payment
+            unless payment.is_a?(::PaymentRecipes::PayPal::REST::Payment)
+              raise Exception, "Parameter payment must be a PaymentRecipes::PayPal::Payment"
+            end
+
+            @payment = payment
+            @payment_id = payment.id
+          end
+
+          extract_and_store(paypal_authorization)
+          @expanded = expanded
+        end
+
+        def reload!
+          paypal_authorization = self.class.find_raw(@id)
+          extract_and_store(paypal_authorization)
+          @expanded = true
+
+          self
+        end
+
+        def reload_payment!
+          @payment = ::PaymentRecipes::PayPal::REST::Payment.find(@payment_id) 
+
+          @payment
+        end
+
+        def payment
+          reload_payment! unless @payment
+
+          @payment
+        end
+
+        def payment_mode
+          reload! unless @payment_mode
+
+          @payment_mode
+        end
+
+        def protection_eligibility
+          reload! unless @protection_eligibility
+
+          @protection_eligibility
+        end
+
+        def protection_eligibility_type
+          reload! unless @protection_eligibility_type
+
+          @protection_eligibility_type
+        end
+
+        def captures
+          payment.captures
+        end
+
+        def capture
+          captures.first
+        end
+
+        def inspect
+          to_str
+        end
+
+        def pending?
+          @state == :pending
+        end
+
+        def authorized?
+          @state == :authorized
+        end
+
+        def partially_captured?
+          @state == :partially_captured
+        end
+
+        def captured?
+          @state == :captured
+        end
+
+        def expired?
+          @state == :expired
+        end
+
+        def voided?
+          @state == :voided
+        end
+
+        def can_be_captured?
+          authorized? || partially_captured?
+        end
+
+        def to_s
+          to_str
+        end
+
+        def to_str
+          "<#{ self.class.name } total=#{ @total.format } state=#{ @state } id=#{ @id }>"
+        end
+
+        class << self
+          def find(id)
+            paypal_authorization = find_raw(id)
+
+            if paypal_authorization
+              new(paypal_authorization, payment: nil, expanded: true)
+            else
+              nil
+            end
+          end
+
+          def find_raw(id)
+            begin
+              ::PayPal::SDK::REST::Authorization.find(id)
+
+            rescue ::PayPal::SDK::Core::Exceptions::ResourceNotFound
+              nil
+            end
+          end
+        end
+
+        private
+
+        def extract_and_store(paypal_authorization)
+          @id                           = convert_to_string(paypal_authorization.id)
+          @currency                     = convert_to_string(paypal_authorization.amount.currency)
+          @total                        = convert_to_money(amount: paypal_authorization.amount.total, currency: @currency)
+          @subtotal                     = convert_to_money(amount: paypal_authorization.amount.details.subtotal, currency: @currency)
+          @create_time                  = convert_to_time(paypal_authorization.create_time)
+          @update_time                  = convert_to_time(paypal_authorization.update_time)
+          @valid_until                  = convert_to_time(paypal_authorization.valid_until)
+          @payment_id                   = convert_to_string(paypal_authorization.parent_payment)
+          @state                        = convert_to_symbol(paypal_authorization.state)
+          @raw_authorization            = paypal_authorization
+
+          @payment_mode                 = convert_to_string(paypal_authorization.payment_mode)
+          @protection_eligibility       = convert_to_string(paypal_authorization.protection_eligibility)
+          @protection_eligibility_type  = convert_to_string(paypal_authorization.protection_eligibility_type)
+        end
+      end
+    end
+  end
+end

data/lib/payment_recipes/paypal/rest/capture.rb

@@ -0,0 +1,140 @@
+module PaymentRecipes
+  module PayPal
+    module REST
+      class Capture
+        attr_reader :currency
+        attr_reader :total
+        attr_reader :create_time
+        attr_reader :id
+        attr_reader :payment
+        attr_reader :payment_id
+        attr_reader :state
+        attr_reader :update_time
+        attr_reader :transaction_fee
+        attr_reader :raw_capture
+
+        include ::PaymentRecipes::Utils::Converters
+        include ::PaymentRecipes::Utils::Equality
+
+        def initialize(paypal_capture, payment: nil)
+          unless paypal_capture.is_a?(::PayPal::SDK::REST::DataTypes::Capture)
+            raise Exception, "#{ self.class.name } must be initialized with a PayPal Capture" 
+          end
+
+          if payment
+            unless payment.is_a?(::PaymentRecipes::PayPal::REST::Payment)
+              raise Exception, "Parameter payment must be a PaymentRecipes::PayPal::Payment"
+            end
+
+            @payment = payment
+            @payment_id = payment.id
+          end
+
+          extract_and_store(paypal_capture)
+        end
+
+        def reload!
+          paypal_capture = self.class.find_raw(@id)
+          extract_and_store(paypal_capture)
+
+          self
+        end
+
+        def reload_payment!
+          @payment = ::PaymentRecipes::PayPal::REST::Payment.find(@payment_id) 
+
+          @payment
+        end
+
+        def payment
+          reload_payment! unless @payment
+
+          @payment
+        end
+
+        def authorizations
+          payment.authorizations
+        end
+
+        def authorization
+          payment.authorization
+        end
+
+        def refunds
+          payment.refunds.select do |refund|
+            refund.capture_id == @id
+          end
+        end
+
+        def refund
+          refunds.first
+        end
+
+        def can_be_refunded?
+          completed?
+        end
+
+        def pending?
+          @state == :pending
+        end
+
+        def completed?
+          @state == :completed
+        end
+
+        def refunded?
+          @state = :refunded
+        end
+
+        def partially_refunded?
+          @state = :partially_refunded
+        end
+
+        def inspect
+          to_str
+        end
+
+        def to_s
+          to_str
+        end
+
+        def to_str
+          "<#{ self.class.name } total=#{ @total.format } state=#{ @state } id=#{ @id }>"
+        end
+
+        class << self
+          def find(id)
+            paypal_capture = find_raw(id)
+
+            if paypal_capture
+              new(paypal_capture, payment: nil)
+            else
+              nil
+            end
+          end
+
+          def find_raw(id)
+            begin
+              ::PayPal::SDK::REST::Capture.find(id)
+
+            rescue ::PayPal::SDK::Core::Exceptions::ResourceNotFound
+              nil
+            end
+          end
+        end
+
+        def extract_and_store(paypal_capture)
+          @currency                     = convert_to_string(paypal_capture.amount.currency)
+          @total                        = convert_to_money(amount: paypal_capture.amount.total, currency: @currency)
+          @create_time                  = convert_to_time(paypal_capture.create_time)
+          @update_time                  = convert_to_time(paypal_capture.update_time)
+          @id                           = convert_to_string(paypal_capture.id)
+          @payment_id                   = convert_to_string(paypal_capture.parent_payment)
+          @state                        = convert_to_symbol(paypal_capture.state)
+          @transaction_fee              = convert_to_money(amount: paypal_capture.transaction_fee.value, currency: paypal_capture.transaction_fee.currency)
+          @raw_capture                  = paypal_capture
+        end
+      end
+    end
+  end
+end

data/lib/payment_recipes/paypal/rest/payer.rb

@@ -0,0 +1,38 @@
+module PaymentRecipes
+  module PayPal
+    module REST
+      class Payer
+        attr_reader :payment_method
+        attr_reader :funding_instruments
+        attr_reader :raw_payer
+
+        include ::PaymentRecipes::Utils::Converters
+
+        def initialize(paypal_payer)
+          unless paypal_payer.is_a?(::PayPal::SDK::REST::DataTypes::Payer)
+            raise Exception, "#{ self.class.name } must be initialized with a PayPal Payer" 
+          end
+
+          @payment_method = convert_to_symbol(paypal_payer.payment_method)
+          @raw_payer      = paypal_payer
+        end
+
+        def funding_instrument
+          @funding_instruments.first
+        end
+
+        def inspect
+          to_str
+        end
+
+        def to_s
+          to_str
+        end
+
+        def to_str
+          "<#{ self.class.name } payment_method=#{ @payment_method }>"
+        end
+      end
+    end
+  end
+end

data/lib/payment_recipes/paypal/rest/payment.rb

@@ -0,0 +1,126 @@
+module PaymentRecipes
+  module PayPal
+    module REST
+      class Payment
+        attr_reader :id
+        attr_reader :intent
+        attr_reader :create_time
+        attr_reader :update_time
+        attr_reader :state
+        attr_reader :transactions
+        attr_reader :sales
+        attr_reader :authorizations
+        attr_reader :captures
+        attr_reader :refunds
+        attr_reader :payer
+        attr_reader :raw_payment
+
+        include ::PaymentRecipes::Utils::Converters
+        include ::PaymentRecipes::Utils::Equality
+
+        def initialize(paypal_payment, expand: false)
+          unless paypal_payment.is_a?(::PayPal::SDK::REST::DataTypes::Payment)
+            raise Exception, "#{ self.class.name } must be initialized with a PayPal Payment" 
+          end
+
+          extract_and_store(paypal_payment, expand: expand)
+        end
+
+        def reload!
+          paypal_payment = self.class.find_raw(@id)
+          extract_and_store(paypal_payment)
+
+          self
+        end
+
+        def transaction
+          @transactions.first
+        end
+
+        def sale
+          @sales.first
+        end
+
+        def authorization
+          @authorizations.first
+        end
+
+        def capture
+          @captures.first
+        end
+
+        def refund
+          @refunds.first
+        end
+
+        def inspect
+          to_str
+        end
+
+        def to_s
+          to_str
+        end
+
+        def to_str
+          "<#{ self.class.name } intent=#{ @intent } state=#{ @state } id=#{ @id }>"
+        end
+
+        class << self
+          def find(id, expand: false)
+            paypal_payment = find_raw(id)
+
+            if paypal_payment
+              new(paypal_payment, expand: expand)
+            else
+              nil
+            end
+          end
+
+          def find_raw(id)
+            begin
+              ::PayPal::SDK::REST::Payment.find(id)
+
+            rescue ::PayPal::SDK::Core::Exceptions::ResourceNotFound
+              nil
+            end
+          end
+
+          def history(count:, page: 1, expand: false)
+            paypal_payment_history = ::PayPal::SDK::REST::Payment.all(count: count, start_index: count * (page - 1))
+
+            paypal_payment_history.payments.map do |paypal_payment|
+              new(paypal_payment, expand: expand)
+            end
+          end
+        end
+
+        private
+
+        def extract_and_store(paypal_payment, expand: false)
+          @id               = convert_to_string(paypal_payment.id)
+          @intent           = convert_to_symbol(paypal_payment.intent)
+          @create_time      = convert_to_time(paypal_payment.create_time)
+          @update_time      = convert_to_time(paypal_payment.update_time)
+          @state            = convert_to_symbol(paypal_payment.state)
+          @raw_payment      = paypal_payment
+          @transactions     = []
+          @sales            = []
+          @authorizations   = []
+          @captures         = []
+          @refunds          = []
+          @payer            = ::PaymentRecipes::PayPal::REST::Payer.new(paypal_payment.payer)
+
+          paypal_payment.transactions.each do |paypal_transaction|
+            transaction = ::PaymentRecipes::PayPal::REST::Transaction.new(paypal_transaction, payment: self, expand: expand)
+            @sales += transaction.sales
+            @authorizations += transaction.authorizations
+            @captures += transaction.captures
+            @refunds += transaction.refunds
+
+            @transactions << transaction
+          end
+        end
+      end
+    end
+  end
+end