payment_recipes 0.0.9 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dfae9ce52297d8a794125ce5948cf2b989993d0a
-  data.tar.gz: d839c8a5412422a3a90149cbf981924f6d05b27e
+  metadata.gz: 6b7d9a4d62f0859042531a4e4e810c35f12c5c0f
+  data.tar.gz: 88704cdd2e845b0a999305403f47aa165095ae8c
 SHA512:
-  metadata.gz: 30df4c816c12db1862120cfa03c440bf9712e348c6d91416e6d393e3f5e44a1a391535fc257de62ba7535360891626b0a5957b7154f645233aa1107e4a5a8595
-  data.tar.gz: 832612a488131917e861d959ceec6a16c897d299cdbabbcd45ceeca97585d4ff71b69c87e60d956c59c65f91c545453e1e0d0f93b4a7b7dd28fdac8fce632a50
+  metadata.gz: a47e76ee300adf8d56d0fedacd4cfa76a20d7041ba402ab3cc0a609c63fc0403439179a01c5336fb4636706d1f0296b04dbb106149344af7511900df1a15691b
+  data.tar.gz: 32e5432bdd57b93f8c8a44671f7ce6408747a3dce8c489f31f4fc4b62a9fe28e26f4dd14ddfc48099c50cbf457df42de4f185ab390055d889ddbdb3d7782237e

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

@@ -0,0 +1,25 @@
+module PaymentRecipes
+  module PayPal
+    module Action
+      class CaptureAuthorization < PaymentRecipes::Utils::Action
+        variable :authorization, ::PaymentRecipes::PayPal::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

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

@@ -0,0 +1,66 @@
+module PaymentRecipes
+  module PayPal
+    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
+
+          @paypal_payment = ::PayPal::SDK::REST::Payment.new(payment_attributes)
+          @paypal_payment.create
+
+          @payment = ::PaymentRecipes::PayPal::Payment.find(@paypal_payment.id)
+
+          @payment
+        end
+
+        def payment
+          @payment
+        end
+
+        def paypal_payment
+          @paypal_payment
+        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

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

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

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

@@ -0,0 +1,22 @@
+module PaymentRecipes
+  module PayPal
+    module Action
+      class RefundCapture < PaymentRecipes::Utils::Action
+        variable :capture, PaymentRecipes::PayPal::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

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

@@ -0,0 +1,22 @@
+module PaymentRecipes
+  module PayPal
+    module Action
+      class RefundSale < PaymentRecipes::Utils::Action
+        variable :sale, PaymentRecipes::PayPal::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

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

@@ -0,0 +1,22 @@
+module PaymentRecipes
+  module PayPal
+    module Action
+      class VoidAuthorization < PaymentRecipes::Utils::Action
+        variable :authorization, PaymentRecipes::PayPal::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

data/lib/payment_recipes/paypal/authorization.rb

@@ -0,0 +1,170 @@
+module PaymentRecipes
+  module PayPal
+    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::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::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

data/lib/payment_recipes/paypal/capture.rb

@@ -0,0 +1,138 @@
+module PaymentRecipes
+  module PayPal
+    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::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::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

data/lib/payment_recipes/paypal/payer.rb

@@ -0,0 +1,36 @@
+module PaymentRecipes
+  module PayPal
+    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

data/lib/payment_recipes/paypal/payment.rb

@@ -0,0 +1,124 @@
+module PaymentRecipes
+  module PayPal
+    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::Payer.new(paypal_payment.payer)
+
+        paypal_payment.transactions.each do |paypal_transaction|
+          transaction = ::PaymentRecipes::PayPal::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

data/lib/payment_recipes/paypal/refund.rb

@@ -0,0 +1,158 @@
+module PaymentRecipes
+  module PayPal
+    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::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::Payment.find(@payment_id) 
+
+        @payment
+      end
+
+      def reload_sale!
+        return unless @sale_id
+
+        @sale = ::PaymentRecipes::PayPal::Sale.find(@sale_id)
+
+        @sale
+      end
+
+      def reload_capture!
+        return unless @capture_id
+
+        @capture = ::PaymentRecipes::PayPal::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

data/lib/payment_recipes/paypal/sale.rb

@@ -0,0 +1,170 @@
+module PaymentRecipes
+  module PayPal
+    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::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::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

data/lib/payment_recipes/paypal/settings.rb

@@ -0,0 +1,14 @@
+module PaymentRecipes
+  module PayPal
+    module Settings
+      def self.configure(mode:, client_id:, client_secret:)
+        ::PayPal::SDK.configure(
+          :mode => mode.to_s, # "sandbox" or "live"
+          :client_id => client_id,
+          :client_secret => client_secret,
+          :ssl_options => { } 
+        )
+      end
+    end
+  end
+end

data/lib/payment_recipes/paypal/transaction.rb

@@ -0,0 +1,116 @@
+module PaymentRecipes
+  module PayPal
+    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::Payment)
+          raise Exception, "Parameter payment must be a PaymentRecipes::PayPal::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::Sale.new(paypal_related_resource.sale, payment: payment)
+            sale.reload! if expand
+
+            @sales << sale
+          end
+
+          if paypal_related_resource.authorization.id
+            authorization = ::PaymentRecipes::PayPal::Authorization.new(paypal_related_resource.authorization, payment: payment)
+            authorization.reload! if expand
+
+            @authorizations << authorization
+          end
+
+          if paypal_related_resource.capture.id
+            capture = ::PaymentRecipes::PayPal::Capture.new(paypal_related_resource.capture, payment: payment)
+            @captures << capture
+          end
+
+          if paypal_related_resource.refund.id
+            refund = ::PaymentRecipes::PayPal::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

data/lib/payment_recipes/utils/action.rb

@@ -0,0 +1,39 @@
+module PaymentRecipes
+  module Utils
+    class Action
+      class << self
+        def variable(key, klass)
+          @rules ||= {}
+          @rules[key] = klass
+
+          define_method key do
+            instance_variable_get("@#{ key }".to_sym)
+          end
+        end
+
+        def rules
+          @rules
+        end
+
+        def prepare(parameters)
+          @rules.each do |key, klass|
+            unless parameters[key].is_a?(klass)
+              raise Exception, "#{ key } should be a #{ klass }"
+            end
+          end
+
+          new(parameters)
+        end
+      end
+
+      def initialize(parameters)
+        raise Exception, "Action params should be a Hash" unless parameters.is_a?(Hash)
+
+        @params = parameters
+        @params.each do |param, value|
+          instance_variable_set("@#{ param }".to_sym, value)
+        end
+      end
+    end
+  end
+end

data/lib/payment_recipes/utils/converters.rb

@@ -0,0 +1,45 @@
+module PaymentRecipes
+  module Utils
+    module Converters
+      def convert_to_time(target)
+        nil_check(target) do
+          if defined?(Time.zone)
+            Time.zone.parse(target)
+          else
+            Time.parse(target)
+          end
+        end
+      end
+
+      def convert_to_string(target)
+        nil_check(target) do
+          target.to_s
+        end
+      end
+
+      def convert_to_money(amount:, currency:)
+        nil_check(amount, currency) do
+          raise Exception, "Money amount must be a String" unless amount.is_a?(String)
+
+          ::Money.new(::BigDecimal.new(amount) * 100, currency)
+        end
+      end
+
+      def convert_to_symbol(target)
+        nil_check(target) do
+          target.to_sym
+        end
+      end
+
+      private
+
+      def nil_check(*target)
+        if target.any? {|x| x.nil?}
+          nil
+        else
+          yield if block_given?
+        end
+      end
+    end
+  end
+end

data/lib/payment_recipes/utils/equality.rb

@@ -0,0 +1,9 @@
+module PaymentRecipes
+  module Utils
+    module Equality
+      def ==(other)
+        @id = other.id && self.class.name == other.class.name
+      end
+    end
+  end
+end

data/lib/payment_recipes/version.rb

@@ -0,0 +1,3 @@
+module PaymentRecipes
+  VERSION = '1.0.0'
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: payment_recipes
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 1.0.0
 platform: ruby
 authors:
 - Joshua Arvin Lat
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-08 00:00:00.000000000 Z
+date: 2017-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: money
@@ -74,6 +74,24 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/payment_recipes.rb
+- lib/payment_recipes/paypal/action/capture_authorization.rb
+- lib/payment_recipes/paypal/action/create_payment.rb
+- lib/payment_recipes/paypal/action/execute_payment.rb
+- lib/payment_recipes/paypal/action/refund_capture.rb
+- lib/payment_recipes/paypal/action/refund_sale.rb
+- lib/payment_recipes/paypal/action/void_authorization.rb
+- lib/payment_recipes/paypal/authorization.rb
+- lib/payment_recipes/paypal/capture.rb
+- lib/payment_recipes/paypal/payer.rb
+- lib/payment_recipes/paypal/payment.rb
+- lib/payment_recipes/paypal/refund.rb
+- lib/payment_recipes/paypal/sale.rb
+- lib/payment_recipes/paypal/settings.rb
+- lib/payment_recipes/paypal/transaction.rb
+- lib/payment_recipes/utils/action.rb
+- lib/payment_recipes/utils/converters.rb
+- lib/payment_recipes/utils/equality.rb
+- lib/payment_recipes/version.rb
 homepage: ''
 licenses:
 - MIT