payment_recipes 1.0.1 → 1.1.0

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

@@ -0,0 +1,160 @@
+module PaymentRecipes
+  module PayPal
+    module REST
+      class Refund
+        attr_reader :id
+        attr_reader :currency
+        attr_reader :total
+        attr_reader :payment
+        attr_reader :payment_id
+        attr_reader :state  
+        
+        attr_reader :create_time 
+        attr_reader :update_time  
+
+        attr_reader :sale_id 
+        attr_reader :sale
+
+        attr_reader :capture_id  
+        attr_reader :capture
+
+        attr_reader :raw_refund 
+
+        include ::PaymentRecipes::Utils::Converters
+        include ::PaymentRecipes::Utils::Equality
+
+        def initialize(paypal_refund, payment: nil)
+          unless paypal_refund.is_a?(::PayPal::SDK::REST::DataTypes::Refund)
+            raise Exception, "#{ self.class.name } must be initialized with a PayPal Refund"
+          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_refund)
+        end
+
+        def reload!
+          paypal_refund = self.class.find_raw(@id)
+          extract_and_store(paypal_refund)
+
+          self
+        end
+
+        def reload_payment!
+          @payment = ::PaymentRecipes::PayPal::REST::Payment.find(@payment_id) 
+
+          @payment
+        end
+
+        def reload_sale!
+          return unless @sale_id
+
+          @sale = ::PaymentRecipes::PayPal::REST::Sale.find(@sale_id)
+
+          @sale
+        end
+
+        def reload_capture!
+          return unless @capture_id
+
+          @capture = ::PaymentRecipes::PayPal::REST::Capture.find(@capture_id)
+
+          @capture
+        end
+
+        def payment
+          reload_payment! unless @payment
+
+          @payment
+        end
+
+        def capture
+          reload_capture! unless @capture
+
+          @capture
+        end
+
+        def sale
+          reload_sale! unless @sale
+
+          @sale
+        end
+
+        def authorizations
+          payment.authorizations
+        end
+
+        def authorization
+          payment.authorization
+        end
+
+        def pending?
+          @state == :pending
+        end
+
+        def completed?
+          @state == :completed
+        end
+
+        def failed?
+          @state == :failed
+        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_refund = find_raw(id)
+
+            if paypal_refund
+              new(paypal_refund, payment: nil)
+            else
+              nil
+            end
+          end
+
+          def find_raw(id)
+            begin
+              ::PayPal::SDK::REST::Refund.find(id)
+
+            rescue ::PayPal::SDK::Core::Exceptions::ResourceNotFound
+              nil
+            end
+          end
+        end
+
+        def extract_and_store(paypal_refund)
+          @id               = convert_to_string(paypal_refund.id)
+          @currency         = convert_to_string(paypal_refund.amount.currency)
+          @total            = convert_to_money(amount: paypal_refund.amount.total, currency: paypal_refund.amount.currency)
+          @payment_id       = convert_to_string(paypal_refund.parent_payment)
+          @state            = convert_to_symbol(paypal_refund.state)
+          
+          @create_time      = convert_to_time(paypal_refund.create_time)
+          @update_time      = convert_to_time(paypal_refund.update_time)
+
+          @sale_id          = convert_to_string(paypal_refund.sale_id)
+          @capture_id       = convert_to_string(paypal_refund.capture_id)
+          @raw_refund       = paypal_refund
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,172 @@
+module PaymentRecipes
+  module PayPal
+    module REST
+      class Sale
+        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 :payment_mode
+        attr_reader :protection_eligibility
+        attr_reader :protection_eligibility_type
+
+        attr_reader :expanded
+        attr_reader :raw_sale
+
+        include ::PaymentRecipes::Utils::Converters
+        include ::PaymentRecipes::Utils::Equality
+
+        def initialize(paypal_sale, payment: nil, expanded: false)
+          unless paypal_sale.is_a?(::PayPal::SDK::REST::DataTypes::Sale)
+            raise Exception, "#{ self.class.name } must be initialized with a PayPal Sale" 
+          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_sale)
+          @expanded = expanded
+        end
+
+        def reload!
+          paypal_sale = self.class.find_raw(@id)
+          extract_and_store(paypal_sale)
+          @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 transaction_fee
+          reload! unless @transaction_fee
+
+          @transaction_fee
+        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 refunds
+          payment.refunds.select do |refund|
+            refund.sale_id == @id
+          end
+        end
+
+        def refund
+          refunds.first
+        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
+
+        def can_be_refunded?
+          completed?
+        end
+
+        def completed?
+          @state == :completed
+        end
+
+        def partially_refunded?
+          @state == :partially_refunded
+        end
+
+        def pending?
+          @state == :pending
+        end
+
+        def refunded?
+          @state == :refunded
+        end
+
+        def denied?
+          @state == :denied
+        end
+
+        class << self
+          def find(id)
+            paypal_sale = find_raw(id)
+
+            if paypal_sale
+              new(paypal_sale, payment: nil, expanded: true)
+            else
+              nil
+            end
+          end
+
+          def find_raw(id)
+            begin
+              ::PayPal::SDK::REST::Sale.find(id)
+
+            rescue ::PayPal::SDK::Core::Exceptions::ResourceNotFound
+              nil
+            end
+          end
+        end
+
+        def extract_and_store(paypal_sale)
+          @currency                     = convert_to_string(paypal_sale.amount.currency)
+          @total                        = convert_to_money(amount: paypal_sale.amount.total, currency: @currency)
+          @create_time                  = convert_to_time(paypal_sale.create_time)
+          @update_time                  = convert_to_time(paypal_sale.update_time)
+          @id                           = convert_to_string(paypal_sale.id)
+          @payment_id                   = convert_to_string(paypal_sale.parent_payment)
+          @state                        = convert_to_symbol(paypal_sale.state)
+          @raw_sale                     = paypal_sale
+
+          @transaction_fee              = convert_to_money(amount: paypal_sale.transaction_fee.value, currency: paypal_sale.transaction_fee.currency)
+          @payment_mode                 = convert_to_string(paypal_sale.payment_mode)
+          @protection_eligibility       = convert_to_string(paypal_sale.protection_eligibility)
+          @protection_eligibility_type  = convert_to_string(paypal_sale.protection_eligibility_type)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module PaymentRecipes
+  module PayPal
+    module REST
+      module Settings
+        def self.configure(live: false, client_id:, client_secret:)
+          mode = live ? "live" : "sandbox"
+
+          ::PayPal::SDK.configure(
+            :mode => mode,
+            :client_id => client_id,
+            :client_secret => client_secret,
+            :ssl_options => { } 
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,118 @@
+module PaymentRecipes
+  module PayPal
+    module REST
+      class Transaction
+        attr_reader :currency
+        attr_reader :total
+        attr_reader :payment
+        attr_reader :payment_id
+        attr_reader :description
+
+        attr_reader :subtotal
+        attr_reader :tax
+        attr_reader :fee
+        attr_reader :shipping
+        attr_reader :handling_fee
+        attr_reader :insurance
+        attr_reader :shipping_discount
+        attr_reader :insurance
+        attr_reader :gift_wrap
+
+        attr_reader :sales
+        attr_reader :authorizations
+        attr_reader :captures
+        attr_reader :refunds
+
+        attr_reader :raw_transaction
+
+        include ::PaymentRecipes::Utils::Converters
+
+        def initialize(paypal_transaction, payment:, expand: false)
+          unless paypal_transaction.is_a?(::PayPal::SDK::REST::DataTypes::Transaction)
+            raise Exception, "#{ self.class.name } must be initialized with a PayPal Transaction" 
+          end
+
+          unless payment.is_a?(::PaymentRecipes::PayPal::REST::Payment)
+            raise Exception, "Parameter payment must be a PaymentRecipes::PayPal::REST::Payment"
+          end
+
+          @currency           = convert_to_string(paypal_transaction.amount.currency)
+          @total              = convert_to_money(amount: paypal_transaction.amount.total, currency: @currency)
+          @description        = convert_to_string(paypal_transaction.description)
+          @payment            = payment
+          @payment_id         = payment.id
+
+          @subtotal           = convert_to_money(amount: paypal_transaction.amount.details.subtotal, currency: @currency)
+          @tax                = convert_to_money(amount: paypal_transaction.amount.details.tax, currency: @currency)
+          @fee                = convert_to_money(amount: paypal_transaction.amount.details.fee, currency: @currency)
+          @shipping           = convert_to_money(amount: paypal_transaction.amount.details.shipping, currency: @currency)
+          @handling_fee       = convert_to_money(amount: paypal_transaction.amount.details.handling_fee, currency: @currency)
+          @insurance          = convert_to_money(amount: paypal_transaction.amount.details.insurance, currency: @currency)
+          @shipping_discount  = convert_to_money(amount: paypal_transaction.amount.details.shipping_discount, currency: @currency)
+          @insurance          = convert_to_money(amount: paypal_transaction.amount.details.insurance, currency: @currency)
+          @gift_wrap          = convert_to_money(amount: paypal_transaction.amount.details.gift_wrap, currency: @currency)
+          @raw_transaction    = paypal_transaction
+
+          @sales              = []
+          @authorizations     = []
+          @captures           = []
+          @refunds            = []
+
+          paypal_transaction.related_resources.each do |paypal_related_resource|
+            if paypal_related_resource.sale.id 
+              sale = ::PaymentRecipes::PayPal::REST::Sale.new(paypal_related_resource.sale, payment: payment)
+              sale.reload! if expand
+
+              @sales << sale
+            end
+
+            if paypal_related_resource.authorization.id
+              authorization = ::PaymentRecipes::PayPal::REST::Authorization.new(paypal_related_resource.authorization, payment: payment)
+              authorization.reload! if expand
+
+              @authorizations << authorization
+            end
+
+            if paypal_related_resource.capture.id
+              capture = ::PaymentRecipes::PayPal::REST::Capture.new(paypal_related_resource.capture, payment: payment)
+              @captures << capture
+            end
+
+            if paypal_related_resource.refund.id
+              refund = ::PaymentRecipes::PayPal::REST::Refund.new(paypal_related_resource.refund, payment: payment)
+              @refunds << refund
+            end
+          end
+        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 } total=#{ @total.format } sales=#{ @sales.size } authorizations=#{ @authorizations.size } captures=#{ @captures.size }>"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+"""
+PayPal::SDK::Merchant::DataTypes::DoCaptureResponseType
+   ├── Ack: Success
+   ├── Build: ***
+   ├── CorrelationID: ***
+   ├── DoCaptureResponseDetails: PayPal::SDK::Merchant::DataTypes::DoCaptureResponseDetailsType
+   │   ├── AuthorizationID: ***
+   │   └── PaymentInfo: PayPal::SDK::Merchant::DataTypes::PaymentInfoType
+   │       ├── ExchangeRate: nil
+   │       ├── FeeAmount: PayPal::SDK::Merchant::DataTypes::BasicAmountType
+   │       │   ├── currencyID: USD
+   │       │   └── value: 0.33
+   │       │
+   │       ├── GrossAmount: PayPal::SDK::Merchant::DataTypes::BasicAmountType
+   │       │   ├── currencyID: USD
+   │       │   └── value: 1.00
+   │       │
+   │       ├── ParentTransactionID: ***
+   │       ├── PaymentDate: 2017-02-05T18:15:36+00:00
+   │       ├── PaymentStatus: Completed
+   │       ├── PaymentType: instant
+   │       ├── PendingReason: none
+   │       ├── ProtectionEligibility: Ineligible
+   │       ├── ProtectionEligibilityType: None
+   │       ├── ReasonCode: none
+   │       ├── ReceiptID: 5351-7638-9795-5628
+   │       ├── TaxAmount: PayPal::SDK::Merchant::DataTypes::BasicAmountType
+   │       │   ├── currencyID: USD
+   │       │   └── value: 0.00
+   │       │
+   │       ├── TransactionID: ***
+   │       └── TransactionType: web-accept
+   │    
+   ├── Timestamp: 2017-02-05T18:15:37+00:00
+   └── Version: 106.0
+"""
+
+module PaymentRecipes
+  module PayPal
+    module SOAP
+      module Action
+        class CaptureAuthorization < PaymentRecipes::Utils::Action
+          variable :authorization_id, "String"
+          variable :amount, "Hash"
+
+          def perform
+            prepare_soap_api
+
+            do_capture_authorization
+
+            if response.success?
+              load_transaction
+            end
+
+            response
+          end
+
+          def prepare_soap_api
+            store(:api) do
+              ::PaymentRecipes::PayPal::SOAP::Settings.api
+            end
+          end
+
+          def response
+            do_capture_response
+          end
+
+          def do_capture_authorization
+            do_capture = api.build_do_capture({
+              :AuthorizationID => authorization_id,
+              :Amount => amount,
+              :CompleteType => "Complete" })
+
+            store(:do_capture_response) do
+              capture_response = api.do_capture(do_capture)
+
+              unless capture_response.success?
+                @error = capture_response.errors
+
+                capture_response = nil
+              end
+
+              capture_response
+            end
+          end
+
+          def load_transaction
+            store(:authorization_transaction) do
+              ::PaymentRecipes::PayPal::SOAP::Transaction.find(authorization_id)
+            end
+
+            store(:capture_transaction) do
+              ::PaymentRecipes::PayPal::SOAP::Transaction.find(capture_id)
+            end
+          end
+
+          def capture_id
+            response.do_capture_response_details.payment_info.transaction_id
+          end
+        end
+      end
+    end
+  end
+end

data/lib/payment_recipes/paypal/soap/action/create_express_checkout_payment.rb

@@ -0,0 +1,76 @@
+module PaymentRecipes
+  module PayPal
+    module SOAP
+      module Action
+        class CreateExpressCheckout < PaymentRecipes::Utils::Action
+          variable :details, "Hash"
+          variable :intent, "Symbol"
+
+          def perform
+            prepare_soap_api
+            modify_details
+            set_express_checkout
+
+            get_express_checkout_url
+          end
+
+          def prepare_soap_api
+            store(:api) do
+              ::PaymentRecipes::PayPal::SOAP::Settings.api
+            end
+          end
+
+          def modify_details
+            unless [:sale, :authorize].include?(intent)
+              raise Exception, "Allowed values for intent: :sale, :authorize"
+            end
+
+            store(:express_checkout_details) do
+              payment_action = if intent == :sale
+                                 'Sale'
+                               elsif intent == :authorize
+                                 'Authorization'
+                               end
+
+              details[:SetExpressCheckoutRequestDetails][:PaymentDetails][0][:PaymentAction] = payment_action
+
+              details
+            end
+          end
+
+          def set_express_checkout
+            set_express_checkout = api.build_set_express_checkout(express_checkout_details)
+
+            store(:set_express_checkout_response) do
+              response = api.set_express_checkout(set_express_checkout)
+
+              unless response.success?
+                @error = response.errors
+
+                response = nil
+              end
+
+              response
+            end
+          end
+
+          def response
+            set_express_checkout_response
+          end
+
+          def get_express_checkout_url
+            store(:express_checkout_redirect_url) do
+              if set_express_checkout_response
+                api.express_checkout_url(set_express_checkout_response)
+              end
+            end
+          end
+
+          def redirect_url
+            express_checkout_redirect_url
+          end 
+        end
+      end
+    end
+  end
+end