trado_paypal_module 0.9.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: eb0fc1e85e04eec3a1950232e9d16b9209263dba
+  data.tar.gz: 2865fc5e70d08593d5fa176c9be02582f0fa73bc
+SHA512:
+  metadata.gz: 9ce411a3afd6fd97697e65cb7d6f24c130d75b94da7b4326fafadaa5ac8e01db4f8d49a5310a39c7ec67978d961397ead41b8c34a58592f37193fe31baec63ee
+  data.tar.gz: 388365d0b59ccfa689da49dc8876a12c2b226c31d1785e34af14f5dfdf3fe52707db304f98243bc2bf122775f224498d287ca7cb46549aca448f49a2c1ff20e2

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2016 Tom Dallimore
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,34 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'TradoPaypalModule'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/app/controllers/trado_paypal_module/ipn_controller.rb

@@ -0,0 +1,26 @@
+class TradoPaypalModule::IpnController < ApplicationController
+  skip_before_action :authenticate_user!
+
+  # TODO: Find out why this is throwing an error.
+  include ActiveMerchant::Billing::Integrations
+
+  # Handler for incoming Instant Payment Notifications from paypal about orders
+  def update
+    notify = Paypal::Notification.new(request.raw_post)
+    
+    if notify.acknowledge
+      transaction = Transaction.where(order_id: notify.params['invoice']).first
+      if notify.complete? and transaction.gross_amount.to_s == notify.params['mc_gross']
+        transaction.fee = notify.params['mc_fee']
+        transaction.completed!
+      else
+        transaction.failed!
+      end
+      if transaction.save
+        Mailatron4000::Orders.confirmation_email(transaction.order) rescue Rails.logger.warn("PayPal IPN: Order #{transaction.order.id} confirmation email failed to send")
+      end
+    end
+
+    render nothing: true
+  end
+end

data/app/controllers/trado_paypal_module/paypal_controller.rb

@@ -0,0 +1,36 @@
+class TradoPaypalModule::PaypalController < ApplicationController
+    skip_before_action :authenticate_user!
+    include CartBuilder
+
+    def confirm
+        set_order
+        set_cart_totals
+        set_grouped_countries
+        set_browser_data
+        @order.attributes = params[:order]
+        if @order.save
+            @order.calculate(current_cart, Store.tax_rate)
+            generate_payment_url
+            if @redirect_url.nil?
+                flash_message :error, 'An error ocurred with your order. Please try again.'
+                Rails.logger.error "PayPal: Unable to generate redirect URL."
+                redirect_to checkout_carts_url
+            else
+                redirect_to @redirect_url
+            end
+        else
+            flash_message :error, 'An error ocurred with your order. Please try again.'
+            render theme_presenter.page_template_path('carts/checkout'), layout: theme_presenter.layout_template_path
+        end
+    rescue ActiveMerchant::ConnectionError
+        flash_message :error, 'An error ocurred with your order. Please try again.'  
+        Rails.logger.error "PayPal: API is temporarily unavailable."
+        redirect_to checkout_carts_url
+    end
+
+    private
+
+    def generate_payment_url
+        @redirect_url = Store::PayProvider.new(cart: current_cart, order: @order, provider: @order.payment_type, ip_address: request.remote_ip).build
+    end
+end

data/config/routes.rb

@@ -0,0 +1,3 @@
+TradoPaypalModule::Engine.routes.draw do
+    post 'ipn', to: 'trado_paypal_module/ipn#update', as: 'paypal_ipn'
+end

data/lib/generators/templates/controller.rb

@@ -0,0 +1,6 @@
+class Carts::PaypalController < TradoPaypalModule::PaypalController
+
+    def confirm
+        super
+    end
+end

data/lib/generators/templates/helper.rb

@@ -0,0 +1,6 @@
+module PaypalHelper
+
+    def paypal_form_tag f
+        raw("<div class='paypal-form-wrapper'>#{f.radio_button(:payment_type, 'paypal', checked: true)}#{image_tag('paypal-icon.png')}</div>")
+    end
+end

data/lib/generators/templates/migration.rb

@@ -0,0 +1,13 @@
+class AddPaypalAttributes < ActiveRecord::Migration
+    def self.up
+        add_column :transactions, :paypal_id, :string
+        add_column :orders, :paypal_express_token, :string
+        add_column :orders, :paypal_express_payer_id, :string
+    end
+
+    def self.down
+        remove_column :transactions, :paypal_id
+        remove_column :orders, :paypal_express_token
+        remove_column :orders, :paypal_express_payer_id
+    end
+end

data/lib/generators/trado_paypal_module/install_generator.rb

@@ -0,0 +1,91 @@
+module TradoPaypalModule
+	module Generators
+		class InstallGenerator < Rails::Generators::Base
+			source_root File.expand_path("../../templates", __FILE__)
+
+			def copy_migration
+				unless paypal_migration_already_exists?
+					timestamp_number = Time.now.utc.strftime("%Y%m%d%H%M%S").to_i
+					copy_file "migration.rb", "db/migrate/#{timestamp_number}_add_paypal_attributes.rb"
+				end
+			end
+
+			def copy_helper
+				template "helper.rb", "app/helpers/paypal_helper.rb"
+			end
+
+			def copy_controller
+				template "controller.rb", "app/controllers/carts/paypal_controller.rb"
+			end
+
+			def setup_routes
+				route_content = <<-CONTENT
+
+	mount TradoPaypalModule::Engine => '/paypal'
+				CONTENT
+				inject_into_file "config/routes.rb", route_content, after: "Trado::Application.routes.draw do"
+			end
+
+			def assign_model_concerns
+				order_content = <<-CONTENT
+
+	has_order_paypal
+				CONTENT
+				transaction_content = <<-CONTENT
+
+	has_transaction_paypal
+				CONTENT
+
+				inject_into_file "app/models/order.rb", order_content, after: "class Order < ActiveRecord::Base"
+				inject_into_file "app/models/transaction.rb", transaction_content, after: "class Transaction < ActiveRecord::Base"
+			end
+
+			def setup_env_configs
+				development_content = <<-CONTENT
+
+	# PayPal settings
+	config.after_initialize do
+	    ActiveMerchant::Billing::Base.mode = :test
+	    paypal_options = {
+	     	login: Rails.application.secrets.paypal_login,
+	     	password: Rails.application.secrets.paypal_password,
+	     	signature: Rails.application.secrets.paypal_signature
+	    }
+	    ::EXPRESS_GATEWAY = ActiveMerchant::Billing::PaypalExpressGateway.new(paypal_options)
+	end
+				CONTENT
+
+				test_content = <<-CONTENT
+
+	# PayPal settings
+	config.after_initialize do
+		ActiveMerchant::Billing::Base.mode = :test
+	    ::EXPRESS_GATEWAY = ActiveMerchant::Billing::BogusGateway.new
+	end
+				CONTENT
+
+				production_content = <<-CONTENT
+
+	# PayPal settings
+	config.after_initialize do
+	    paypal_options = {
+	    	login: Rails.application.secrets.paypal_login,
+	    	password: Rails.application.secrets.paypal_password,
+	    	signature: Rails.application.secrets.paypal_signature
+	    }
+	    ::EXPRESS_GATEWAY = ActiveMerchant::Billing::PaypalExpressGateway.new(paypal_options)
+	end
+				CONTENT
+				inject_into_file "config/environments/development.rb", development_content, after: "Trado::Application.configure do"
+				inject_into_file "config/environments/test.rb", test_content, after: "Trado::Application.configure do"
+				inject_into_file "config/environments/production.rb", production_content, after: "Trado::Application.configure do"
+			end
+
+			private
+
+			def paypal_migration_already_exists?
+				Dir.glob("#{File.join(destination_root, File.join("db", "migrate"))}/[0-9]*_*.rb").grep(/\d+_add_paypal_attributes.rb$/).first
+			end
+		end
+	end
+end

data/lib/tasks/trado_paypal_module_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :trado_paypal_module do
+#   # Task goes here
+# end

data/lib/trado_paypal_module.rb

@@ -0,0 +1,12 @@
+module TradoPaypalModule
+end
+
+require 'activemerchant'
+require 'offsite_payments'
+
+require 'trado_paypal_module/engine'
+require 'trado_paypal_module/version'
+require 'trado_paypal_module/active_record'
+require 'trado_paypal_module/paypaler'
+
+ActiveRecord::Base.send(:include, TradoPaypalModule::ActiveRecord)

data/lib/trado_paypal_module/active_record.rb

@@ -0,0 +1,15 @@
+module TradoPaypalModule
+    module ActiveRecord
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+            def has_order_paypal
+                attr_accessible :paypal_express_token, :paypal_express_payer_id
+            end
+
+            def has_transaction_paypal
+                attr_accessible :paypal_id
+            end
+        end
+    end
+end

data/lib/trado_paypal_module/engine.rb

@@ -0,0 +1,6 @@
+require 'rails'
+
+module TradoPaypalModule
+    class Engine < Rails::Engine
+    end
+end

data/lib/trado_paypal_module/paypaler.rb

@@ -0,0 +1,219 @@
+require_dependency 'lib/payatron_4000'
+
+module TradoPaypalModule
+
+    class Paypaler
+
+        # Builds the a PayPal purchase request from the order data
+        # If successful, redirect to PayPal for the user to login
+        # If unsuccessful, redirect to failed order page
+        #
+        # @param cart [Object]
+        # @param order [Object]
+        # @param ip_address [String]
+        # @return [String] redirect url
+        def self.build cart, order, ip_address
+          response = EXPRESS_GATEWAY.setup_purchase(
+                        Store::Price.new(price: order.gross_amount, tax_type: 'net').singularize, 
+                        TradoPaypalModule::Paypaler.express_setup_options( 
+                          order,
+                          cart,
+                          ip_address, 
+                          Rails.application.routes.url_helpers.confirm_order_url(order, host: Trado::Application.config.action_mailer.default_url_options[:host]), 
+                          Rails.application.routes.url_helpers.mycart_carts_url(host: Trado::Application.config.action_mailer.default_url_options[:host])
+                        )
+          )
+          if response.success?
+            return EXPRESS_GATEWAY.redirect_url_for(response.token)
+          else
+            TradoPaypalModule::Paypaler.failed(response, order)
+            Payatron4000.decommission_order(order)
+            return Rails.application.routes.url_helpers.failed_order_url(order, host: Trado::Application.config.action_mailer.default_url_options[:host])
+          end
+        end
+
+        # Creates the payment information object for PayPal to parse in the login
+        #
+        # @param order [Object]
+        # @param cart [Object]
+        # @param ip_address [String]
+        # @param return_url [String]
+        # @param cancel_url [String]
+        # @return [Object] order data from the store for PayPal
+        def self.express_setup_options order, cart, ip_address, return_url, cancel_url
+            {
+              :subtotal               => Store::Price.new(price: (order.net_amount - order.delivery.price), tax_type: 'net').singularize,
+              :shipping               => Store::Price.new(price: order.delivery.price, tax_type: 'net').singularize,
+              :tax                    => Store::Price.new(price: order.tax_amount, tax_type: 'net').singularize,
+              :handling               => 0,
+              :order_id               => order.id,
+              :items                  => TradoPaypalModule::Paypaler.express_items(cart.cart_items),
+              :address_override       => 1,
+              :shipping_address       => order.delivery_address.full_address,
+              :req_confirm_shipping   => 0,
+              :ip                     => ip_address,
+              :return_url             => return_url,
+              :cancel_return_url      => cancel_url,
+              :currency               => Store.settings.currency_code,
+            }
+        end
+
+        # Creates the payment information object for PayPal to parse in the confirmation step and complete the purchase
+        #
+        # @param order [Object]
+        # @return [Object] current customer order
+        def self.express_purchase_options order, ip_address
+            {
+              :subtotal          => Store::Price.new(price: (order.net_amount - order.delivery.price), tax_type: 'net').singularize,
+              :shipping          => Store::Price.new(price: order.delivery.price, tax_type: 'net').singularize,
+              :tax               => Store::Price.new(price: order.tax_amount, tax_type: 'net').singularize,
+              :handling          => 0,
+              :items             => TradoPaypalModule::Paypaler.express_items(order.order_items),
+              :token             => order.paypal_express_token,
+              :payer_id          => order.paypal_express_payer_id,
+              :currency          => Store.settings.currency_code,
+              :ip                => ip_address,
+            }
+        end
+
+        # Creates an aray of items which represent cart_items or order_items
+        # This is passed into the express_setup_options and express_purchase_options methods
+        #
+        # @return [Array] list of cart or order items for PayPal
+        def self.express_items items
+            items.collect do |item|
+                {
+                  :name               => "#{item.sku.product.name} (#{item.sku.variants.map{|v| v.name.titleize}.join(' / ')})",
+                  :description        => "#{item.sku.product.name} (#{item.sku.variants.map{|v| v.name.titleize}.join(' / ')})",
+                  :amount             => Store::Price.new(price: item.price, tax_type: 'net').singularize, 
+                  :quantity           => item.quantity 
+                }
+            end
+        end
+
+        # Assign PayPal token to order after user logs into their account
+        #
+        # @param token [String]
+        # @param payer_id [Integer]
+        # @param order [Object]
+        def self.assign_paypal_token token, payer_id, order
+            order.paypal_express_token = token
+            order.paypal_express_payer_id = payer_id
+            order.save(validate: false)
+        end
+
+        # Completes the order process by communicating with PayPal; receives a response and in turn creates the relevant transaction records,
+        # sends a confirmation email and redirects the user.
+        #
+        # @param order [Object]
+        # @param session [Object
+        def self.complete order, session, ip_address
+          order.transfer(order.cart)
+          response = EXPRESS_GATEWAY.purchase(Store::Price.new(price: order.gross_amount, tax_type: 'net').singularize, 
+                                              TradoPaypalModule::Paypaler.express_purchase_options(order, ip_address)
+          )
+          if response.success?
+            TradoPaypalModule::Paypaler.successful(response, order)
+            Payatron4000.destroy_cart(session)
+            Payatron4000.decommission_order(order)
+            order.reload
+            Mailatron4000::Orders.confirmation_email(order)
+            return Rails.application.routes.url_helpers.success_order_url(order, host: Trado::Application.config.action_mailer.default_url_options[:host])
+          else
+            TradoPaypalModule::Paypaler.failed(response, order)
+            order.reload
+            Mailatron4000::Orders.confirmation_email(order)
+            return Rails.application.routes.url_helpers.failed_order_url(order, host: Trado::Application.config.action_mailer.default_url_options[:host])
+          end
+        end
+
+        # Upon successfully completing an order with a PayPal payment option a new transaction record is created, stock is updated for the relevant SKU
+        #
+        # @param response [Object]
+        # @param order [Object]
+        def self.successful response, order
+            Transaction.new(  :fee                      => response.params['PaymentInfo']['FeeAmount'],  
+                              :order_id                 => order.id, 
+                              :payment_status           => response.params['PaymentInfo']['PaymentStatus'].downcase, 
+                              :transaction_type         => 'Credit', 
+                              :tax_amount               => response.params['PaymentInfo']['TaxAmount'], 
+                              :paypal_id                => response.params['PaymentInfo']['TransactionID'], 
+                              :payment_type             => 'paypal',
+                              :net_amount               => response.params['PaymentInfo']['GrossAmount'].to_d - response.params['PaymentInfo']['TaxAmount'].to_d,
+                              :gross_amount             => response.params['PaymentInfo']['GrossAmount'],
+                              :status_reason            => response.params['PaymentInfo']['PendingReason']
+            ).save(validate: false)
+            Payatron4000.update_stock(order)
+            Payatron4000.increment_product_order_count(order.products)
+        end
+
+        
+        # When an order has failed to complete, a new transaction record is created with a logged status reason
+        #
+        # @param response [Object]
+        # @param order [Object]
+        def self.failed response, order
+            Transaction.new(  :fee                        => 0, 
+                              :gross_amount               => order.gross_amount, 
+                              :order_id                   => order.id, 
+                              :payment_status             => 'failed', 
+                              :transaction_type           => 'Credit', 
+                              :tax_amount                 => order.tax_amount, 
+                              :paypal_id                  => nil, 
+                              :payment_type               => 'paypal',
+                              :net_amount                 => order.net_amount,
+                              :status_reason              => response.message,
+                              :error_code                 => response.params["error_codes"].to_i
+            ).save(validate: false)
+            Payatron4000.increment_product_order_count(order.products)
+        end
+
+        # A list of available currency codes for the PayPal payment system
+        #
+        # @return [Array] available currency codes
+        def self.currency_codes
+          return [
+            "AUD",
+            "CAD",
+            "CZK",
+            "DKK",
+            "EUR",
+            "HKD",
+            "HUF",
+            "ILS",
+            "JPY",
+            "MXN",
+            "NOK",
+            "NZD",
+            "PHP",
+            "PLN",
+            "GBP",
+            "RUB",
+            "SGD",
+            "SEK",
+            "CHF",
+            "TWD",
+            "THB",
+            "USD"
+          ]
+        end
+
+        # A list of fatal error codes for an order
+        # If the passed in error code parameter is included in the fatal codes array, return true
+        #
+        # @param error_code [Integer] payment error code
+        # @return [Boolean]
+        def self.fatal_error_code? error_code
+            @fatal_codes =
+            [
+                10412, # PayPal: Payment has already been made for this InvoiceID.
+                10415 # PayPal: A successful transaction has already been completed for this token.
+            ]
+            return @fatal_codes.include?(error_code) ? true : false
+        end
+
+        def self.valid_tokens? params
+          params[:token].present? && params[:PayerID].present?
+        end
+    end
+end