solidus_paypal_braintree 0.1.0

data/app/models/solidus_paypal_braintree/transaction.rb

@@ -0,0 +1,30 @@
+require 'active_model'
+
+module SolidusPaypalBraintree
+  class Transaction
+    include ActiveModel::Model
+
+    attr_accessor :nonce, :payment_method, :payment_type, :address, :email, :phone
+
+    validates :nonce, presence: true
+    validates :payment_method, presence: true
+    validates :payment_type, presence: true
+    validates :phone, presence: true
+    validates :email, presence: true
+
+    validate do
+      unless payment_method.is_a? SolidusPaypalBraintree::Gateway
+        errors.add(:payment_method, 'Must be braintree')
+      end
+      if address && !address.valid?
+        address.errors.each do |field, error|
+          errors.add(:address, "#{field} #{error}")
+        end
+      end
+    end
+
+    def address_attributes=(attributes)
+      self.address = TransactionAddress.new attributes
+    end
+  end
+end

data/app/models/solidus_paypal_braintree/transaction_address.rb

@@ -0,0 +1,66 @@
+require 'active_model'
+
+module SolidusPaypalBraintree
+  class TransactionAddress
+    include ActiveModel::Model
+    include ActiveModel::Validations::Callbacks
+    include SolidusPaypalBraintree::CountryMapper
+
+    attr_accessor :country_code, :last_name, :first_name,
+      :city, :zip, :state_code, :address_line_1, :address_line_2
+
+    validates :first_name, :last_name, :address_line_1, :city, :zip,
+      :state_code, :country_code, presence: true
+
+    before_validation do
+      self.country_code = country_code.presence || "us"
+    end
+
+    validates :spree_country, presence: true
+    validates :spree_state, presence: true, if: :should_match_state_model?
+
+    def initialize(attributes = {})
+      country_name = attributes.delete(:country_name) || ""
+      if attributes[:country_code].blank?
+        attributes[:country_code] = iso_from_name(country_name)
+      end
+
+      super(attributes)
+    end
+
+    def spree_country
+      country_code && (@country ||= Spree::Country.find_by(iso: country_code.upcase))
+    end
+
+    def spree_state
+      spree_country && state_code && ( @state ||= spree_country.states.where(
+        Spree::State.arel_table[:name].matches(state_code).or(
+          Spree::State.arel_table[:abbr].matches(state_code)
+        )
+      ).first )
+    end
+
+    def to_spree_address
+      address = Spree::Address.new first_name: first_name,
+        last_name: last_name,
+        city: city,
+        country: spree_country,
+        address1: address_line_1,
+        address2: address_line_2,
+        zipcode: zip
+
+      if spree_state
+        address.state = spree_state
+      else
+        address.state_name = state_code
+      end
+      address
+    end
+
+    # Check to see if this address should match to a state
+    #   model in the database.
+    def should_match_state_model?
+      spree_country.present? && spree_country.states.any?
+    end
+  end
+end

data/app/models/solidus_paypal_braintree/transaction_import.rb

@@ -0,0 +1,92 @@
+require 'active_model'
+
+module SolidusPaypalBraintree
+  class TransactionImport
+    class InvalidImportError < StandardError; end
+
+    include ActiveModel::Model
+
+    validate do
+      errors.add("Address", "is invalid") if address && !address.valid?
+
+      if !transaction.valid?
+        transaction.errors.each do |field, error|
+          errors.add(field, error)
+        end
+      end
+      errors.none?
+    end
+
+    attr_reader :transaction, :order
+
+    def initialize(order, transaction)
+      @order = order
+      @transaction = transaction
+    end
+
+    def source
+      SolidusPaypalBraintree::Source.new nonce: transaction.nonce,
+        payment_type: transaction.payment_type,
+        payment_method: transaction.payment_method,
+        user: user
+    end
+
+    def user
+      order.user
+    end
+
+    def import!(end_state)
+      if valid?
+        order.email = user.try!(:email) || transaction.email
+
+        if address
+          order.shipping_address = order.billing_address = address
+          # work around a bug in most solidus versions
+          # about tax zone cachine between address changes
+          order.instance_variable_set("@tax_zone", nil)
+        end
+
+        payment = order.payments.new source: source,
+          payment_method: transaction.payment_method,
+          amount: order.total
+
+        order.save!
+        advance_order(payment, end_state)
+      else
+        raise InvalidImportError,
+          "Validation failed: #{errors.full_messages.join(', ')}"
+      end
+    end
+
+    def address
+      transaction.address && transaction.address.to_spree_address.tap do |address|
+        address.phone = transaction.phone
+      end
+    end
+
+    def state_before_current?(state)
+      steps = order.checkout_steps
+      steps.index(state) < (steps.index(order.state) || 0)
+    end
+
+    protected
+
+    def advance_order(payment, end_state)
+      return if state_before_current?(end_state)
+
+      until order.state == end_state
+        order.next!
+        update_payment_total(payment) if order.payment?
+      end
+    end
+
+    def update_payment_total(payment)
+      payment_total = order.payments.where(state: %w[checkout pending]).sum(:amount)
+      remaining_total = order.outstanding_balance - payment_total
+
+      if remaining_total > 0
+        payment.update!(amount: payment.amount + remaining_total)
+      end
+    end
+  end
+end

data/app/models/spree/store_decorator.rb

@@ -0,0 +1,11 @@
+Spree::Store.class_eval do
+  has_one :braintree_configuration, class_name: "SolidusPaypalBraintree::Configuration", dependent: :destroy
+
+  before_create :build_default_configuration
+
+  private
+
+  def build_default_configuration
+    build_braintree_configuration
+  end
+end

data/app/overrides/admin_navigation_menu.rb

@@ -0,0 +1,6 @@
+Deface::Override.new(
+  virtual_path: "spree/admin/shared/_settings_sub_menu",
+  name: "solidus_paypal_braintree_admin_navigation_configuration",
+  insert_bottom: "[data-hook='admin_settings_sub_tabs']",
+  partial: "solidus_paypal_braintree/configurations/admin_tab"
+)

data/app/views/spree/shared/_braintree_hosted_fields.html.erb

@@ -0,0 +1,26 @@
+<% prefix = "payment_source[#{id}]" %>
+
+<div class="hosted-fields">
+  <div class="field" data-hook="card_number">
+    <%= label_tag "card_number#{id}", Spree::CreditCard.human_attribute_name(:number), class: "required" %>
+    <div class="input" id="card_number<%= id %>"></div>
+  </div>
+
+  <div class="field" data-hook="card_expiration">
+    <%= label_tag "card_expiry#{id}", Spree::CreditCard.human_attribute_name(:expiration), class: "required" %>
+    <div class="input" id="card_expiry<%= id %>"></div>
+  </div>
+
+  <div class="field" data-hook="card_code">
+    <%= label_tag "card_code#{id}", Spree::CreditCard.human_attribute_name(:card_code), class: "required" %>
+    <div class="input" id="card_code<%= id %>"></div>
+
+    <a href="/content/cvv" class="info cvvLink" target="_blank">
+      (<%= Spree.t(:what_is_this) %>)
+    </a>
+  </div>
+
+  <div class="clear"></div>
+  <input type="hidden" name="<%= prefix %>[payment_type]" value="<%= SolidusPaypalBraintree::Source::CREDIT_CARD %>">
+  <input type="hidden" id="payment_method_nonce" name="<%= prefix %>[nonce]">
+</div>

data/config/initializers/braintree.rb

@@ -0,0 +1 @@
+Spree::Admin::PaymentsController.helper :braintree_admin

data/config/locales/en.yml

@@ -0,0 +1,30 @@
+en:
+  activerecord:
+    models:
+      solidus_paypal_braintree/gateway: Braintree
+  spree:
+    admin:
+      tab:
+        braintree: Braintree
+    client_sdk_enabled: Client SDK enabled?
+    environment: Environment
+    merchant_currency_map: Merchant currency map
+    merchant_id: Merchant ID
+    paypal_payee_email_map: Paypal payee email map
+    private_key: Private key
+    public_key: Public key
+    token_generation_enabled: Token generation enabled?
+  solidus_paypal_braintree:
+    braintree: Braintree
+    nonce: Nonce
+    token: Token
+    payment_type:
+      label: Payment Type
+      apple_pay_card: Apple Pay
+      credit_card: Credit Card
+      pay_pal_account: PayPal
+    configurations:
+      title: Braintree Configurations
+      tab: Braintree
+      update_success: Successfully updated Braintree configurations.
+      update_error: An error occurred while updating Braintree configurations.

data/config/routes.rb

@@ -0,0 +1,12 @@
+SolidusPaypalBraintree::Engine.routes.draw do
+  resource :checkout, only: [:update, :edit]
+  resource :client_token, only: [:create], format: :json
+  resource :transactions, only: [:create]
+
+  resources :configurations do
+    collection do
+      get :list
+      post :update
+    end
+  end
+end

data/db/migrate/20160830061749_create_solidus_paypal_braintree_sources.rb

@@ -0,0 +1,16 @@
+class CreateSolidusPaypalBraintreeSources < SolidusSupport::Migration[4.2]
+  def change
+    create_table :solidus_paypal_braintree_sources do |t|
+      t.string :nonce
+      t.string :token
+      t.string :payment_type
+      t.integer :user_id, index: true
+      t.references :customer, index: true
+      t.references :payment_method, index: true
+
+      t.timestamps null: false
+    end
+
+    add_foreign_key :solidus_paypal_braintree_sources, :spree_payment_methods, column: :payment_method_id
+  end
+end

data/db/migrate/20160906201711_create_solidus_paypal_braintree_customers.rb

@@ -0,0 +1,11 @@
+class CreateSolidusPaypalBraintreeCustomers < SolidusSupport::Migration[4.2]
+  def change
+    create_table :solidus_paypal_braintree_customers do |t|
+      t.references :user
+      t.string :braintree_customer_id
+    end
+
+    add_index :solidus_paypal_braintree_customers, :user_id, unique: true, name: "index_braintree_customers_on_user_id"
+    add_index :solidus_paypal_braintree_customers, :braintree_customer_id, unique: true, name: "index_braintree_customers_on_braintree_customer_id"
+  end
+end

data/db/migrate/20161114231422_create_solidus_paypal_braintree_configurations.rb

@@ -0,0 +1,11 @@
+class CreateSolidusPaypalBraintreeConfigurations < SolidusSupport::Migration[4.2]
+  def change
+    create_table :solidus_paypal_braintree_configurations do |t|
+      t.boolean :paypal,    null: false, default: false
+      t.boolean :apple_pay, null: false, default: false
+      t.integer :store_id,  null: false, index: true, foreign_key: { references: :spree_stores }
+
+      t.timestamps null: false
+    end
+  end
+end

data/db/migrate/20161125172005_add_braintree_configuration_to_stores.rb

@@ -0,0 +1,9 @@
+class AddBraintreeConfigurationToStores < SolidusSupport::Migration[4.2]
+  def up
+    Spree::Store.all.each(&:create_braintree_configuration)
+  end
+
+  def down
+    SolidusPaypalBraintree::Configuration.joins(:store).destroy_all
+  end
+end

data/db/migrate/20170203191030_add_credit_card_to_braintree_configuration.rb

@@ -0,0 +1,6 @@
+class AddCreditCardToBraintreeConfiguration < SolidusSupport::Migration[4.2]
+  def change
+    add_column :solidus_paypal_braintree_configurations, :credit_card,
+      :boolean, null: false, default: false
+  end
+end

data/db/migrate/20170505193712_add_null_constraint_to_sources.rb

@@ -0,0 +1,30 @@
+class AddNullConstraintToSources < SolidusSupport::Migration[4.2]
+  def up
+    payments = Spree::Payment.arel_table
+    sources = SolidusPaypalBraintree::Source.arel_table
+    join_sources = payments.join(sources).on(
+      payments[:source_id].eq(sources[:id]).and(
+        payments[:source_type].eq("SolidusPaypalBraintree::Source")
+      ).and(
+        sources[:payment_method_id].eq(nil)
+      )
+    ).join_sources
+
+    count = Spree::Payment.joins(join_sources).count
+    Rails.logger.info("Updating #{count} problematic sources")
+
+    Spree::Payment.joins(join_sources).find_each do |payment|
+      Rails.logger.info("Updating source #{payment.source_id} with payment method id #{payment.payment_method_id}")
+      SolidusPaypalBraintree::Source.where(id: payment.source_id).update_all(payment_method_id: payment.payment_method_id)
+    end
+
+    # We use a foreign key constraint on the model,
+    # but it doesnt make sense to have this model exist without a payment method
+    # as two of its methods delegate to the payment method.
+    change_column_null(:solidus_paypal_braintree_sources, :payment_method_id, false)
+  end
+
+  def down
+    change_column_null(:solidus_paypal_braintree_sources, :payment_method_id, true)
+  end
+end

data/db/migrate/20170508085402_add_not_null_constraint_to_sources_payment_type.rb

@@ -0,0 +1,11 @@
+class AddNotNullConstraintToSourcesPaymentType < SolidusSupport::Migration[4.2]
+  def change
+    reversible do |dir|
+      dir.up do
+        SolidusPaypalBraintree::Source.where(payment_type: nil).
+          update_all(payment_type: 'CreditCard')
+      end
+    end
+    change_column_null(:solidus_paypal_braintree_sources, :payment_type, false)
+  end
+end

data/lib/controllers/backend/solidus_paypal_braintree/configurations_controller.rb

@@ -0,0 +1,30 @@
+module SolidusPaypalBraintree
+  class ConfigurationsController < Spree::Admin::BaseController
+    helper Spree::Core::Engine.routes.url_helpers
+
+    def list
+      authorize! :list, SolidusPaypalBraintree::Configuration
+
+      @configurations = Spree::Store.all.map(&:braintree_configuration)
+    end
+
+    def update
+      authorize! :update, SolidusPaypalBraintree::Configuration
+
+      params = configurations_params[:configuration_fields]
+      if SolidusPaypalBraintree::Configuration.update(params.keys, params.values)
+        flash[:success] = t('update_success', scope: 'solidus_paypal_braintree.configurations')
+      else
+        flash[:error] = t('update_error', scope: 'solidus_paypal_braintree.configurations')
+      end
+      redirect_to action: :list
+    end
+
+    private
+
+    def configurations_params
+      params.require(:configurations).
+        permit(configuration_fields: [:paypal, :apple_pay, :credit_card])
+    end
+  end
+end

data/lib/controllers/frontend/solidus_paypal_braintree/checkouts_controller.rb

@@ -0,0 +1,27 @@
+class SolidusPaypalBraintree::CheckoutsController < Spree::CheckoutController
+  PERMITTED_PAYMENT_PARAMS = [
+    :payment_method_id,
+    source_attributes: [
+      :nonce,
+      :payment_type
+    ]
+  ].freeze
+
+  def update
+    @payment = Spree::PaymentCreate.new(@order, payment_params).build
+
+    if @payment.save
+      render plain: "ok"
+    else
+      render plain: "not-ok"
+    end
+  end
+
+  def payment_params
+    params.
+      require(:order).
+      require(:payments_attributes).
+      first.
+      permit(PERMITTED_PAYMENT_PARAMS)
+  end
+end