spree_first_data_gge4 3.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4d1e67b68700d741e339b31ded55d0dd7cb44cd9
+  data.tar.gz: cc6cd1406fcab82ee5e9656b8bcf600cbafd9e44
+SHA512:
+  metadata.gz: 267a78fd9fe0a7ae711366b5062d066693171cdab8a81c5c4150a9b41bfb47972f78ba1a5f2632ec7bc8509ddb82a23741ef275516d5da4245c181afd545050c
+  data.tar.gz: 8ee7d1314833bd23e71a2fa70aaa9102ea2472c11ddf0ee0ef440d8457ef2e76866ae1e258f75bbaaedf2548b64dc96a174ccff22637434ed61c742db42630e4

data/.gitignore

@@ -0,0 +1,14 @@
+\#*
+*~
+.#*
+.DS_Store
+.idea
+.project
+.sass-cache
+coverage
+Gemfile.lock
+tmp
+nbproject
+pkg
+*.swp
+spec/dummy

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gem 'spree', github: 'spree/spree', branch: '3-0-stable'
+# Provides basic authentication functionality for testing parts of your engine
+gem 'spree_auth_devise', github: 'spree/spree_auth_devise', branch: '3-0-stable'
+
+gemspec

data/LICENSE

@@ -0,0 +1,26 @@
+Copyright (c) 2015 [name of plugin creator]
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the documentation
+      and/or other materials provided with the distribution.
+    * Neither the name Spree nor the names of its contributors may be used to
+      endorse or promote products derived from this software without specific
+      prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,39 @@
+SpreeFirstDataGge4
+==================
+
+Introduction goes here.
+
+Installation
+------------
+
+Add spree_first_data_gge4 to your Gemfile:
+
+```ruby
+gem 'spree_first_data_gge4'
+```
+
+Bundle your dependencies and run the installation generator:
+
+```shell
+bundle
+bundle exec rails g spree_first_data_gge4:install
+```
+
+Testing
+-------
+
+First bundle your dependencies, then run `rake`. `rake` will default to building the dummy app if it does not exist, then it will run specs. The dummy app can be regenerated by using `rake test_app`.
+
+```shell
+bundle
+bundle exec rake
+```
+
+When testing your applications integration with this extension you may use it's factories.
+Simply add this require statement to your spec_helper:
+
+```ruby
+require 'spree_first_data_gge4/factories'
+```
+
+Copyright (c) 2015 [name of extension creator], released under the New BSD License

data/Rakefile

@@ -0,0 +1,21 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+require 'spree/testing_support/extension_rake'
+
+RSpec::Core::RakeTask.new
+
+task :default do
+  if Dir["spec/dummy"].empty?
+    Rake::Task[:test_app].invoke
+    Dir.chdir("../../")
+  end
+  Rake::Task[:spec].invoke
+end
+
+desc 'Generates a dummy app for testing'
+task :test_app do
+  ENV['LIB_NAME'] = 'spree_first_data_gge4'
+  Rake::Task['extension:test_app'].invoke
+end

data/app/assets/javascripts/spree/backend/spree_first_data_gge4.js

@@ -0,0 +1,2 @@
+// Placeholder manifest file.
+// the installer will append this file to the app vendored assets here: vendor/assets/javascripts/spree/backend/all.js'

data/app/assets/javascripts/spree/frontend/spree_first_data_gge4.js

@@ -0,0 +1,2 @@
+// Placeholder manifest file.
+// the installer will append this file to the app vendored assets here: vendor/assets/javascripts/spree/frontend/all.js'

data/app/assets/stylesheets/spree/backend/spree_first_data_gge4.css

@@ -0,0 +1,4 @@
+/*
+Placeholder manifest file.
+the installer will append this file to the app vendored assets here: 'vendor/assets/stylesheets/spree/backend/all.css'
+*/

data/app/assets/stylesheets/spree/frontend/spree_first_data_gge4.css

@@ -0,0 +1,4 @@
+/*
+Placeholder manifest file.
+the installer will append this file to the app vendored assets here: 'vendor/assets/stylesheets/spree/frontend/all.css'
+*/

data/app/models/spree/billing_integration.rb

@@ -0,0 +1,21 @@
+module Spree
+  class BillingIntegration < PaymentMethod
+    validates :name, presence: true
+
+    preference :server, :string, default: 'test'
+    preference :test_mode, :boolean, default: true
+
+    def provider
+      integration_options = options
+      ActiveMerchant::Billing::Base.integration_mode = integration_options[:server].to_sym
+      integration_options[:test] = true if integration_options[:test_mode]
+      @provider ||= provider_class.new(integration_options)
+    end
+
+    def options
+      options_hash = {}
+      preferences.each { |key, value| options_hash[key.to_sym] = value }
+      options_hash
+    end
+  end
+end

data/app/models/spree/billing_integration/skrill/quick_checkout.rb

@@ -0,0 +1,48 @@
+module Spree
+  class BillingIntegration::Skrill::QuickCheckout < BillingIntegration
+    preference :merchant_id, :string
+    preference :language, :string, :default => 'EN'
+    preference :currency, :string, :default => 'EUR'
+    preference :payment_options, :string, :default => 'ACC'
+    preference :pay_to_email, :string ,   :default => 'your@merchant.email_here'
+
+    def provider_class
+      ActiveMerchant::Billing::Skrill
+    end
+
+    def redirect_url(order, opts = {})
+      opts.merge! self.preferences
+
+      set_global_options(opts)
+
+      opts[:detail1_text] = order.number
+      opts[:detail1_description] = "Order:"
+
+      opts[:pay_from_email] = order.email
+      opts[:firstname] = order.bill_address.firstname
+      opts[:lastname] = order.bill_address.lastname
+      opts[:address] = order.bill_address.address1
+      opts[:address2] = order.bill_address.address2
+      opts[:phone_number] = order.bill_address.phone.gsub(/\D/,'') if order.bill_address.phone
+      opts[:city] = order.bill_address.city
+      opts[:postal_code] = order.bill_address.zipcode
+      opts[:state] = order.bill_address.state.nil? ? order.bill_address.state_name.to_s : order.bill_address.state.abbr
+      opts[:country] = order.bill_address.country.name
+      opts[:pay_to_email] = self.preferred_pay_to_email
+      opts[:hide_login] = 1
+      opts[:merchant_fields] = 'platform,order_id,payment_method_id'
+      opts[:platform] = 'Spree'
+      opts[:order_id] = order.number
+
+      skrill = self.provider
+      skrill.payment_url(opts)
+    end
+
+    private
+      def set_global_options(opts)
+        opts[:recipient_description] = Spree::Config[:site_name]
+        opts[:payment_methods] = self.preferred_payment_options
+      end
+
+  end
+end

data/app/models/spree/gateway/authorize_net_cim.rb

@@ -0,0 +1,213 @@
+module Spree
+  class Gateway::AuthorizeNetCim < Gateway
+    preference :login, :string
+    preference :password, :string
+    preference :server, :string, default: "test"
+    preference :test_mode, :boolean, default: false
+    preference :validate_on_profile_create, :boolean, default: false
+
+    ActiveMerchant::Billing::Response.class_eval do
+      attr_writer :authorization
+    end
+
+    def provider_class
+      self.class
+    end
+
+    def options
+      if !['live','test'].include?(self.preferred_server)
+        raise "You must set the 'server' preference in your payment method (Gateway::AuthorizeNetCim) to either 'live' or 'test'"
+      end
+
+      # add :test key in the options hash, as that is what the
+      # ActiveMerchant::Billing::AuthorizeNetGateway expects
+      if self.preferred_server != "live"
+        self.preferences[:test] = true
+      else
+        self.preferences.delete(:test)
+      end
+
+      super
+    end
+
+    def authorize(amount, creditcard, gateway_options)
+      create_transaction(amount, creditcard, :auth_only, transaction_options(gateway_options))
+    end
+
+    def purchase(amount, creditcard, gateway_options)
+      create_transaction(amount, creditcard, :auth_capture, transaction_options(gateway_options))
+    end
+
+    # capture is only one where source is not passed in for payment profile
+    def capture(amount, response_code, gateway_options)
+      # no credit card needed
+      create_transaction(amount, nil, :prior_auth_capture, trans_id: response_code)
+    end
+
+    def credit(amount, creditcard, response_code, gateway_options = {})
+      create_transaction(amount, creditcard, :refund, transaction_options(gateway_options).merge(trans_id: response_code))
+    end
+
+    def void(response_code, creditcard, gateway_options = {})
+      create_transaction(nil, creditcard, :void, transaction_options(gateway_options).merge(trans_id: response_code))
+    end
+
+    def cancel(response_code)
+      # From: http://community.developer.authorize.net/t5/The-Authorize-Net-Developer-Blog/Refunds-in-Retail-A-user-friendly-approach-using-AIM/ba-p/9848
+      # DD: if unsettled, void needed
+      response = void(response_code, nil)
+      # DD: if settled, credit/refund needed
+      response = credit(nil, nil, response_code) unless response.success?
+
+      response
+    end
+
+    def payment_profiles_supported?
+      true
+    end
+
+    # Create a new CIM customer profile ready to accept a payment. Called by Spree::Payment on after_save.
+    def create_profile(payment)
+      if payment.source.gateway_customer_profile_id.nil?
+        profile_hash = create_customer_profile(payment)
+        payment.source.update_attributes(gateway_customer_profile_id: profile_hash[:customer_profile_id], gateway_payment_profile_id: profile_hash[:customer_payment_profile_id])
+      end
+    end
+
+    # Get the CIM payment profile; Needed for updates.
+    def get_profile(payment)
+      if payment.source.has_payment_profile?
+        profile = cim_gateway.get_customer_profile({
+          customer_profile_id: payment.source.gateway_customer_profile_id
+        })
+        if profile
+          profile.params['profile'].deep_symbolize_keys!
+        end
+      end
+    end
+
+    # Get the CIM payment profile; Needed for updates.
+    def get_payment_profile(payment)
+      if payment.source.has_payment_profile?
+        profile = cim_gateway.get_customer_payment_profile({
+          customer_profile_id: payment.source.gateway_customer_profile_id,
+          customer_payment_profile_id: payment.source.gateway_payment_profile_id
+        })
+        if profile
+          profile.params['payment_profile'].deep_symbolize_keys!
+        end
+      end
+    end
+
+    # Update billing address on the CIM payment profile
+    def update_payment_profile(payment)
+      if payment.source.has_payment_profile?
+        if hash = get_payment_profile(payment)
+          hash[:bill_to] = generate_address_hash(payment.order.bill_address)
+          if hash[:payment][:credit_card]
+            # activemerchant expects a credit card object with 'number', 'year', 'month', and 'verification_value?' defined
+            payment.source.define_singleton_method(:number) { "XXXXXXXXX#{payment.source.last_digits}" }
+            hash[:payment][:credit_card] = payment.source
+          end
+          cim_gateway.update_customer_payment_profile({
+            customer_profile_id: payment.source.gateway_customer_profile_id,
+            payment_profile: hash
+          })
+        end
+      end
+    end
+
+    private
+
+      def transaction_options(gateway_options = {})
+        { order: { invoice_number: gateway_options[:order_id] } }
+      end
+
+      # Create a transaction on a creditcard
+      # Set up a CIM profile for the card if one doesn't exist
+      # Valid transaction_types are :auth_only, :capture_only and :auth_capture
+      def create_transaction(amount, creditcard, transaction_type, options = {})
+        creditcard.save if creditcard
+
+        transaction_options = {
+          type: transaction_type
+        }.update(options)
+
+        if amount
+          amount = "%.2f" % (amount / 100.0) # This gateway requires formated decimal, not cents
+          transaction_options.update({
+            amount: amount
+          })
+        end
+
+        if creditcard
+          transaction_options.update({
+            customer_profile_id: creditcard.gateway_customer_profile_id,
+            customer_payment_profile_id: creditcard.gateway_payment_profile_id
+          })
+        end
+
+        logger.debug("\nAuthorize Net CIM Request")
+        logger.debug("  transaction_options: #{transaction_options.inspect}")
+        t = cim_gateway.create_customer_profile_transaction(transaction: transaction_options)
+        logger.debug("\nAuthorize Net CIM Response")
+        logger.debug("  response: #{t.inspect}\n")
+        t
+      end
+
+      # Create a new CIM customer profile ready to accept a payment
+      def create_customer_profile(payment)
+        options = options_for_create_customer_profile(payment)
+        response = cim_gateway.create_customer_profile(options)
+        if response.success?
+          { customer_profile_id: response.params['customer_profile_id'],
+            customer_payment_profile_id: response.params['customer_payment_profile_id_list'].values.first }
+        else
+          payment.send(:gateway_error, response)
+        end
+      end
+
+      def options_for_create_customer_profile(payment)
+        if payment.is_a? CreditCard
+          info = { bill_to: generate_address_hash(payment.address),
+                   payment: { credit_card: payment } }
+        else
+          info = { bill_to: generate_address_hash(payment.order.bill_address),
+                   payment: { credit_card: payment.source } }
+        end
+        validation_mode = preferred_validate_on_profile_create ? preferred_server.to_sym : :none
+
+        { profile: { merchant_customer_id: "#{Time.now.to_f}",
+                     ship_to_list: generate_address_hash(payment.order.ship_address),
+                     email: payment.order.email,
+                     payment_profiles: info },
+          validation_mode: validation_mode }
+      end
+
+      # As in PaymentGateway but with separate name fields
+      def generate_address_hash(address)
+        return {} if address.nil?
+        {
+          first_name: address.firstname,
+          last_name: address.lastname,
+          address1: address.address1,
+          address2: address.address2,
+          city: address.city,
+          state: address.state_text,
+          zip: address.zipcode,
+          country: address.country.iso,
+          phone_number: address.phone
+        }
+      end
+
+      def cim_gateway
+        @_cim_gateway ||= begin
+          ActiveMerchant::Billing::Base.gateway_mode = preferred_server.to_sym
+          gateway_options = options
+          gateway_options[:test_requests] = false # DD: never ever do test requests because just returns transaction_id = 0
+          ActiveMerchant::Billing::AuthorizeNetCimGateway.new(gateway_options)
+        end
+      end
+
+  end
+end

data/app/models/spree/gateway/firstdata_e4.rb

@@ -0,0 +1,12 @@
+module Spree
+  class Gateway::FirstdataE4 < Gateway
+    preference :login, :string
+    preference :password, :password
+
+
+    def provider_class
+      ActiveMerchant::Billing::FirstdataE4Gateway
+    end
+  end
+end
+

data/app/models/spree/gateway/worldpay.rb

@@ -0,0 +1,91 @@
+module Spree
+  class Gateway::Worldpay < Gateway
+    preference :login, :string
+    preference :password, :string
+    preference :currency, :string, :default => 'GBP'
+    preference :installation_id, :string
+
+    preference :american_express_login, :string
+    preference :discover_login, :string
+    preference :jcb_login, :string
+    preference :mastercard_login, :string
+    preference :maestro_login, :string
+    preference :visa_login, :string
+
+    def provider_class
+      ActiveMerchant::Billing::WorldpayGateway
+    end
+
+    def purchase(money, credit_card, options = {})
+      provider = credit_card_provider(credit_card, options)
+      provider.purchase(money, credit_card, options)
+    end
+
+    def authorize(money, credit_card, options = {})
+      provider = credit_card_provider(credit_card, options)
+      provider.authorize(money, credit_card, options)
+    end
+
+    def capture(money, authorization, options = {})
+      provider = credit_card_provider(auth_credit_card(authorization), options)
+      provider.capture(money, authorization, options)
+    end
+
+    def refund(money, authorization, options = {})
+      provider = credit_card_provider(auth_credit_card(authorization), options)
+      provider.refund(money, authorization, options)
+    end
+
+    def credit(money, authorization, options = {})
+      refund(money, authorization, options)
+    end
+
+    def void(authorization, options = {})
+      provider = credit_card_provider(auth_credit_card(authorization), options)
+      provider.void(authorization, options)
+    end
+
+    private
+
+    def options_for_card(credit_card, options)
+      options[:login] = login_for_card(credit_card)
+      options = options().merge( options )
+    end
+
+    def auth_credit_card(authorization)
+      Spree::Payment.find_by_response_code(authorization).source
+    end
+
+    def credit_card_provider(credit_card, options = {})
+      gateway_options = options_for_card(credit_card, options)
+      gateway_options.delete :login if gateway_options.has_key?(:login) and gateway_options[:login].nil?
+      gateway_options[:currency] = self.preferred_currency
+      gateway_options[:inst_id] = self.preferred_installation_id
+      ActiveMerchant::Billing::Base.gateway_mode = gateway_options[:server].to_sym
+      @provider = provider_class.new(gateway_options)
+    end
+
+    def login_for_card(card)
+      case card.brand
+        when 'american_express'
+          choose_login preferred_american_express_login
+        when 'discover'
+          choose_login preferred_discover_login
+        when 'jcb'
+          choose_login preferred_jcb_login
+        when 'maestro'
+          choose_login preferred_maestro_login
+        when 'master'
+          choose_login preferred_mastercard_login
+        when 'visa'
+          choose_login preferred_visa_login
+        else
+          preferred_login
+      end
+    end
+
+    def choose_login(login)
+      return login ? login : preferred_login
+    end
+  end
+end