payment_recipes 1.0.1 → 1.1.0

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

@@ -1,66 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,170 +0,0 @@
-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

@@ -1,138 +0,0 @@
-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

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

@@ -1,124 +0,0 @@
-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