payment_recipes 1.0.1 → 1.1.0

data/lib/payment_recipes/paypal/refund.rb

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

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

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

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