spree_bitpay 0.1.1

data/app/controllers/spree/bitpay_controller.rb

@@ -0,0 +1,248 @@
+module Spree
+  class BitpayController < StoreController
+    skip_before_filter :verify_authenticity_token, :only => [:notification]
+
+    # Generates Bitpay Invoice and returns iframe view
+    #
+    def pay_now
+
+      order = current_order || raise(ActiveRecord::RecordNotFound)
+
+      return redirect_to root_url if order.state != "confirm"
+
+      # Find the payment by searching for valid payments associated with the order
+      # VOID payments are considered valid, so need to exclude those too
+      payments = order.payments.where.not(state: %w(failed invalid void))
+
+      if payments.count > 1  # If there are other completed payments use the one in checkout state
+        payment = payments.where(state: "checkout").first
+      else 
+        payment = payments.first
+      end
+
+      logger.debug "Found payment: #{payment.inspect}"
+
+      case payment.state
+      when "checkout"
+        # New checkout - create an invoice, and attach its id to the payment.source
+        invoice = new_invoice(order, payment)
+        payment.source.invoice_id = invoice['id']
+        payment.source.save!
+        payment.started_processing!
+      else
+        # An invoice was already created - find it
+        invoice = payment.source.find_invoice
+      end
+
+      @invoice_iframe_url = "#{invoice['url']}&view=iframe"
+      render json: @invoice_iframe_url
+    end
+
+    # View Invoice with specific ID
+    #
+    def view_invoice
+      invoice = BitpayInvoice.find(params[:source_id]).find_invoice
+      redirect_to (invoice["url"] + '&view=iframe')
+    end
+
+    def check_payment_state
+      invoice = BitpayInvoice.where(invoice_id: params[:invoice_id]).first
+      pm = PaymentMethod.find(invoice.payment_method_id)
+      status = pm.scan_the_server(invoice.invoice_id)
+      render json: status
+    end
+
+    def cancel
+
+      order = current_order || raise(ActiveRecord::RecordNotFound)
+
+      # Find and invalidate Bitpay payment in processing state
+      order.payments.with_state("processing").each do |payment| 
+        if (payment.payment_method.is_a? Spree::PaymentMethod::Bitpay)
+          payment.state = "invalid"  # Have to set this explicitly since Spree state machine prevents it
+          payment.save!
+        end
+      end
+
+      redirect_to edit_order_url(order, state: 'payment'), :notice => Spree.t(:checkout_cancelled)
+
+    end
+
+    # Fires on receipt of payment received window message
+    #
+    def payment_sent
+
+      order = Spree::Order.find(session[:order_id]) || raise(ActiveRecord::RecordNotFound)
+
+      session[:order_id] = nil # Reset cart
+      redirect_to spree.order_path(order), :notice => Spree.t(:order_processed_successfully)
+
+    end
+
+    ## Handle IPN from Bitpay server
+    # Receives incoming IPN message and retrieves official BitPay invoice for processing
+    #
+    def notification
+
+      posData = JSON.parse(params["posData"])
+
+      order_id = posData["orderID"]
+      payment_id = posData["paymentID"]
+
+      # Get OFFICIAL Invoice from BitPay API
+      # Fetching payment this way should prevent any false payment/order mismatch
+      order = Spree::Order.find_by_number(order_id) || raise(ActiveRecord::RecordNotFound)
+      payment = order.payments.find_by(identifier: payment_id) || raise(ActiveRecord::RecordNotFound)
+      invoice = payment.source.find_invoice
+
+      if invoice
+        logger.debug("Bitpay Invoice Content: " + invoice.to_json)
+        process_invoice(invoice)
+        head :ok
+      else
+        raise "Spree_Bitpay:  No invoice found for notification for #{payment.identifier} from #{request.remote_ip}"
+      end
+
+    rescue
+      logger.error "Spree_Bitpay:  Unprocessable notification received from #{request.remote_ip}: #{params.inspect}"
+      head :unprocessable_entity	
+    end
+
+    # Reprocess Invoice and update order status 
+    #
+    def refresh
+      payment = Spree::Payment.find(params[:payment])  # Retrieve payment by ID
+      old_state = payment.state
+      invoice = payment.source.find_invoice  # Get associated invoice
+      process_invoice(invoice)	# Re-process invoice
+      new_state = payment.reload.state
+      notice = (new_state == old_state) ? Spree.t(:bitpay_payment_not_updated) : (Spree.t(:bitpay_payment_updated) + new_state.titlecase)
+      redirect_to (request.referrer || root_path), notice: notice
+    end
+
+    #######################################################################
+    ###    Private Methods
+    #######################################################################
+
+    private
+
+    # Call Bitpay API and return new JSON invoice object
+    #
+    def new_invoice(order, payment)
+
+      # Have to encode this into a string for proper handling by API
+      posDataJson = {paymentID: payment.identifier, orderID: order.number}.to_json
+
+      invoice_params = {
+        price: order.outstanding_balance,
+        currency: order.currency,
+        orderID: order.number,
+        notificationURL: bitpay_notification_url,
+        posData: posDataJson,
+        fullNotifications: "true"
+      }
+
+      logger.debug "Requesting Invoice with params: #{invoice_params}"
+      invoice = payment.payment_method.get_bitpay_client.post 'invoice', invoice_params
+      logger.debug "Invoice Generated: #{invoice.inspect}"
+
+      return invoice
+    end
+
+    # Process the invoice and adjust order state accordingly
+    # Accepts BitPay JSON invoice object
+    #
+    def process_invoice(invoice)
+      logger.debug "Processing Bitpay invoice"
+
+      # Extract posData
+      posData = JSON.parse(invoice["posData"])
+
+      payment_id = posData["paymentID"]
+      status = invoice["status"]
+      exception_status = invoice["exceptionStatus"]
+
+      payment = Spree::Payment.find_by(identifier: payment_id) || raise(ActiveRecord::RecordNotFound)
+
+      logger.debug "Found Payment: #{payment.inspect}"
+
+      # Advance Payment state according to Spree flow
+      # http://guides.spreecommerce.com/user/payment_states.html
+
+      case status
+      when "new"
+
+        payment.started_processing
+
+      when "paid" 
+
+        # Move payment to pending state and complete order 	
+
+        if payment.state = "processing" # This is the most common scenario
+          payment.pend!
+        else # In the case it was previously marked invalid due to invoice expiry
+          payment.state = "pending"
+          payment.save
+        end
+
+        payment.order.update!
+        payment.order.next
+        if (!payment.order.complete?)
+          raise "Can't transition order #{payment.order.number} to COMPLETE state"	
+        end
+
+      when "confirmed", "complete"
+
+        # Move payment to 'complete' state
+
+        case payment.state
+        when "pending" # This is the most common scenario
+          payment.complete
+        when "completed" 
+          # Do nothing
+        else 
+          # Something unusual happened - maybe a notification was missed, or 
+          # Make sure the order is completed
+          if !payment.order.complete? 
+            payment.state = "pending"
+            payment.save
+            payment.order.next
+            if (!payment.order.complete?)
+              raise "Can't transition order #{payment.order.number} to COMPLETE state"	
+            end
+          end
+          payment.state = "completed"  # Can't use Spree payment.complete! method since we are transitioning from weird states
+          payment.save
+        end
+
+      when "expired"
+
+        if (exception_status == false)  # This is an abandoned invoice
+          payment.state = "invalid"  # Have to set this explicitly since Spree state machine prevents it
+          payment.save!
+        else 
+          # Don't think this will be anything other than paidPartial exceptionStatus
+          unless payment.state == 'void'
+            payment.void!
+          end
+        end
+
+      when "invalid"
+
+        unless payment.state == 'failed' 
+          payment.failure!  # Will be flagged risky automatically
+        end
+
+      else
+
+        raise "Unexpected status received from BitPay: '#{invoice["status"]}' for '#{invoice["url"]}"
+
+      end
+
+      logger.debug "New Payment State for #{payment.identifier}: #{payment.state}"
+      logger.debug "New Order State for #{payment.order.number}: #{payment.order.state}"
+
+    end
+
+  end
+end

data/app/models/spree/bitpay_invoice.rb

@@ -0,0 +1,23 @@
+module Spree
+
+  class BitpayInvoice < ActiveRecord::Base
+    belongs_to :payment_method
+    belongs_to :user
+    has_many :payments, as: :source
+
+    # DB fields: user_id, invoice_id
+
+    attr_accessor :bogus  # bogus since we need to have a param that is passed to trigger Payment.build_source
+
+    def actions
+      # TODO: Refund action?	
+      ["void"]
+    end
+
+    # Gets the JSON invoice from Bitpay
+    def find_invoice
+      payment_method.find_invoice(invoice_id)
+    end
+
+  end
+end

data/app/models/spree/payment_method/bitpay.rb

@@ -0,0 +1,64 @@
+module Spree
+  class PaymentMethod::Bitpay < PaymentMethod
+    preference :api_key, :string
+    preference :api_endpoint, :string, :default => "https://bitpay.com/api"
+
+    def auto_capture?
+      true
+    end
+
+    def payment_source_class
+      Spree::BitpayInvoice
+    end
+
+    # Set true to force confirmation step.
+    # http://guides.spreecommerce.com/developer/checkout.html#confirmation
+    #
+    def payment_profiles_supported?
+      true
+    end
+
+    ## Dummy method to satisfy test factories
+    #
+    def create_profile(payment)
+      nil
+    end
+
+    def source_required?
+      false
+    end
+
+#######################################################################
+###    Instance Utility Methods
+#######################################################################
+
+    ## Retreive Invoice by ID from BitPay
+    #
+    def find_invoice(id)
+      id ? ( get_bitpay_client.get ('invoice/' + id) ) : nil
+    end
+
+      
+    def scan_the_server(id)
+      message = get_bitpay_client.get('invoice/' + id)
+      status = message["status"]
+      return status unless status.nil?
+      error = message["error"]["message"] if status.nil?
+      return error unless error.nil?
+      "unknown error"
+    end
+    
+    ## Interface with BitPay 
+    #
+    def get_bitpay_client
+      BitPay::Client.new(preferred_api_key, {api_uri: preferred_api_endpoint})
+    end
+
+    ## This is a stub method which simply returns true to allow the cancel on the Spree side
+    #
+    def void (action, order_id, id)
+      ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success')
+    end
+
+  end
+end

data/app/overrides/spree/payments/_payment/bitpay_payment_params.html.erb.deface

@@ -0,0 +1,55 @@
+<!-- insert_after 'erb[loud]:contains("payment_method")' -->
+
+<% if (payment.payment_method.is_a? Spree::PaymentMethod::Bitpay) && (payment.state != 'void') %>
+<% pm = payment.payment_method %>
+<%= image_tag("BC_nBG_64px.png") %>
+<script type="text/javascript">
+  $(document).ready(function() {
+    $('[data-hook="buttons"] input[name="commit"]').click(Bitpay.checkout);
+    $('#checkout_form_confirm').removeAttr("action");
+    $('#checkout_form_confirm').removeAttr("method");
+
+    $('#bitpay_checkout_modal').easyModal({
+      overlayClose: false,
+      closeOnEscape: false
+      });
+
+    Bitpay.invoiceUrl = "<%= j bitpay_pay_now_url(pmid: pm.id).html_safe %>";
+    Bitpay.checkUrl = "<%= j bitpay_check_url %>";
+    Bitpay.apiEndpoint = "<%= pm.get_preference(:api_endpoint) %>";			
+  })
+
+window.addEventListener('message', Bitpay.finishCheckout, false);
+
+</script>
+
+<div id="bitpay_checkout_modal">
+  <div id="bitpay_modal_content">
+    <div id="bitpay_invoice">
+      <iframe id="bitpay_invoice_iframe"
+      scrolling="no" 
+      allowtransparency="true" 
+      frameborder="0", >
+      </iframe>
+    </div>
+    <div id="bitpay_checkout_guidance">
+      <span id="instructions"><%= simple_format Spree.t(:bitpay_payment_instructions) %></span>
+      <span id="completed" style="display:none"><%= Spree.t(:bitpay_payment_completed) %></span>
+      <span id="expired" style="display:none"><%= Spree.t(:bitpay_invoice_expired) %></span>
+      </br>
+    </div>
+    <div id="bitpay_payment_buttons" class="form-buttons">
+      <a 	id="continue_to_invoice" 
+      class="button disabled" 
+      disabled="disabled" 
+      href="<%= bitpay_payment_sent_url %>">
+      <span><%= Spree.t(:bitpay_view_invoice) %></span>
+      </a>
+    <%= link_to Spree.t(:bitpay_cancel), bitpay_cancel_url, {id: "choose_another_method", class: "button primary"} %>
+    </div>
+  </div>
+</div>
+
+<% end %>
+
+

data/app/views/spree/admin/payments/source_views/_bitpay.html.erb

@@ -0,0 +1,23 @@
+<% 	invoice = @payment.source.find_invoice  %>
+<% if invoice %>
+	<div class="bitpay_invoice_details">
+		<h3>Bitpay Invoice Details</h3>
+		<pre><%= JSON.pretty_generate(invoice) %></pre>
+	</div>
+
+	<%= link_to Spree.t(:bitpay_refresh_invoice), bitpay_refresh_url(payment: @payment), {id: "refresh_invoice", class: "button primary", title: Spree.t(:bitpay_refresh_invoice_description)} %>
+
+	<div class="bitpay_invoice_details">
+		<h3>Invoice</h3>
+		<iframe id="bitpay_view_invoice_iframe"
+				src="<%= j bitpay_view_invoice_url(source_id: @payment.source).html_safe %>"
+				scrolling="no" 
+				allowtransparency="true" 
+				frameborder="0">
+		</iframe>
+		<br/>
+		<%= link_to Spree.t(:bitpay_view_full_invoice), invoice["url"], {target: "_new"} %>
+	</div>
+<% else %>
+	<p>No BitPay Invoice Available</p>
+<% end %>

data/app/views/spree/checkout/payment/_bitpay.html.erb

@@ -0,0 +1,4 @@
+
+<%= image_tag("BC_nBG_64px.png") %>
+<p><%= Spree.t(:bitpay_payment_method) %></p>
+<%= hidden_field_tag "payment_source[#{payment_method.id}][bogus]", 'bogus', :id => "bogus" %>

data/bin/rails

@@ -0,0 +1,7 @@
+# This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
+
+ENGINE_ROOT = File.expand_path('../..', __FILE__)
+ENGINE_PATH = File.expand_path('../../lib/spree_bitpay/engine', __FILE__)
+
+require 'rails/all'
+require 'rails/engine/commands'

data/config/locales/en.yml

@@ -0,0 +1,16 @@
+en:
+  spree:
+    bitpay_cancel: "Choose another payment method"
+    bitpay_checkout_error: "Error with Bitcoin checkout"
+    bitpay_payment_completed: "Thank you for your payment."
+    bitpay_invoice_expired: "The invoice has expired.  Please re-select Bitcoin if you would like to retry."
+    bitpay_payment_instructions: |
+      Please pay the invoice above to continue.
+      The page will automatically refresh in a few seconds when transaction is broadcast.
+    bitpay_payment_method: "Payment will be requested following the confirmation."
+    bitpay_view_invoice: "Continue to Invoice"
+    bitpay_view_full_invoice: "View invoice at BitPay.com"
+    bitpay_refresh_invoice: "Reprocess Invoice"
+    bitpay_refresh_invoice_description: "Re-poll BitPay invoice and update order status"
+    bitpay_payment_updated: "Payment status changed to: "
+    bitpay_payment_not_updated: "No status change detected."

data/config/routes.rb

@@ -0,0 +1,9 @@
+Spree::Core::Engine.routes.draw do
+  get '/spree_bitpay/invoice/new', :to => "bitpay#pay_now", :as => :bitpay_pay_now
+  get '/spree_bitpay/invoice/view', :to => "bitpay#view_invoice", :as => :bitpay_view_invoice
+  get '/spree_bitpay/payment_sent', :to => "bitpay#payment_sent", :as => :bitpay_payment_sent
+  get '/spree_bitpay/cancel', :to => "bitpay#cancel", :as => :bitpay_cancel
+  get '/spree_bitpay/refresh', :to => "bitpay#refresh", :as => :bitpay_refresh
+  get '/spree_bitpay/check', :to => "bitpay#check_payment_state", :as => :bitpay_check
+  post '/spree_bitpay/notification', :to => "bitpay#notification", :as => :bitpay_notification
+end

data/db/migrate/20140720052959_create_spree_bitpay_invoices.rb

@@ -0,0 +1,8 @@
+class CreateSpreeBitpayInvoices < ActiveRecord::Migration
+  def change
+    create_table :spree_bitpay_invoices do |t|
+      t.string :invoice_id
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20140725200946_add_fields_to_spree_bitpay_invoice.rb

@@ -0,0 +1,14 @@
+class AddFieldsToSpreeBitpayInvoice < ActiveRecord::Migration
+  def change
+
+  	unless Spree::BitpayInvoice.column_names.include? "payment_method_id"
+    	add_column :spree_bitpay_invoices, :payment_method_id, :integer
+    	add_index  :spree_bitpay_invoices, :payment_method_id
+	end
+
+	unless Spree::BitpayInvoice.column_names.include? "user_id"
+	    add_column :spree_bitpay_invoices, :user_id, :integer
+	end
+
+  end
+end

data/db/migrate/20140729192827_add_index_to_spree_payments.rb

@@ -0,0 +1,5 @@
+class AddIndexToSpreePayments < ActiveRecord::Migration
+  def change
+  	add_index :spree_payments, :identifier
+  end
+end

data/lib/generators/spree_bitpay/install/install_generator.rb

@@ -0,0 +1,32 @@
+module SpreeBitpay
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+
+      class_option :auto_run_migrations, :type => :boolean, :default => false
+
+      def add_javascripts
+        append_file 'vendor/assets/javascripts/spree/frontend/all.js', "//= require spree/frontend/spree_bitpay\n"
+        append_file 'vendor/assets/javascripts/spree/frontend/all.js', "//= require easyModal.js-master/jquery.easyModal\n"
+        append_file 'vendor/assets/javascripts/spree/backend/all.js', "//= require spree/backend/spree_bitpay\n"
+      end
+
+      def add_stylesheets
+        inject_into_file 'vendor/assets/stylesheets/spree/frontend/all.css', " *= require spree/frontend/spree_bitpay\n", :before => /\*\//, :verbose => true
+        inject_into_file 'vendor/assets/stylesheets/spree/backend/all.css', " *= require spree/backend/spree_bitpay\n", :before => /\*\//, :verbose => true
+      end
+
+      def add_migrations
+        run 'bundle exec rake railties:install:migrations FROM=spree_bitpay'
+      end
+
+      def run_migrations
+        run_migrations = options[:auto_run_migrations] || ['', 'y', 'Y'].include?(ask 'Would you like to run the migrations now? [Y/n]')
+        if run_migrations
+          run 'bundle exec rake db:migrate'
+        else
+          puts 'Skipping rake db:migrate, don\'t forget to run it!'
+        end
+      end
+    end
+  end
+end

data/lib/spree_bitpay/engine.rb

@@ -0,0 +1,28 @@
+require 'bitpay'
+
+module SpreeBitpay
+  class Engine < Rails::Engine
+    require 'spree/core'
+    isolate_namespace Spree
+    engine_name 'spree_bitpay'
+
+    # use rspec for tests
+    config.generators do |g|
+      g.test_framework :rspec
+    end
+
+    initializer "spree.bitpay.payment_methods", :after => "spree.register.payment_methods" do |app|
+      app.config.spree.payment_methods << Spree::PaymentMethod::Bitpay
+    end
+
+    def self.activate
+      Dir.glob(File.join(File.dirname(__FILE__), '../../app/**/*_decorator*.rb')) do |c|
+        Rails.configuration.cache_classes ? require(c) : load(c)
+      end
+    end
+
+    config.to_prepare &method(:activate).to_proc
+  end
+end
+
+Spree::PermittedAttributes.source_attributes.push(:bogus)

data/lib/spree_bitpay/factories.rb

@@ -0,0 +1,6 @@
+FactoryGirl.define do
+  # Define your Spree extensions Factories within this file to enable applications, and other extensions to use and override them.
+  #
+  # Example adding this to your spec_helper will load these Factories for use:
+  # require 'spree_bitpay/factories'
+end

data/lib/spree_bitpay/version.rb

@@ -0,0 +1,3 @@
+module SpreeBitpay
+  VERSION = "1.0.1"
+end

data/lib/spree_bitpay.rb

@@ -0,0 +1,3 @@
+require 'spree_core'
+require 'spree_bitpay/version'
+require 'spree_bitpay/engine'

data/script/rails

@@ -0,0 +1,7 @@
+# This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
+
+ENGINE_ROOT = File.expand_path('../..', __FILE__)
+ENGINE_PATH = File.expand_path('../../lib/spree_bitpay/engine', __FILE__)
+
+require 'rails/all'
+require 'rails/engine/commands'

data/spec/factories/bitpay_test_factories.rb

@@ -0,0 +1,54 @@
+## Factories for setting up Spree BitPay inflight orders/payments 
+# 
+#
+
+# Easily recognizable dummy values
+
+PAYMENT_ID = "123PAYMENTID"
+ORDER_ID   = "123ORDERID"
+INVOICE_ID = "123BitPayInvoiceID"
+
+
+FactoryGirl.define do
+  ## Creates a payment in 'processing' state with associated order in 'confirm' state
+  #
+  factory :abstract_btc_payment, class: Spree::Payment do
+    association :payment_method, factory: :bitcoin_payment_method
+    association :source, factory: :bitcoin_invoice
+    amount { order.total }
+    response_code 'BTC'
+    after(:create) do |payment|
+      payment.identifier = PAYMENT_ID
+      payment.save!
+      payment.order.update!
+    end
+
+    factory :processing_payment_with_confirming_order do
+      state 'processing'
+      association :order, factory: :order_with_line_items, state: "confirm", number: ORDER_ID
+    end
+
+    factory :pending_payment_with_complete_order do
+      state 'pending'
+      association :order, factory: :order_with_line_items, state: "complete", number: ORDER_ID
+    end
+
+    factory :invalid_payment_with_confirming_order do
+      state 'invalid'
+      association :order, factory: :order_with_line_items, state: "confirm", number: ORDER_ID
+    end    
+
+  end
+
+  factory :bitcoin_payment_method, class: Spree::PaymentMethod::Bitpay do
+    name 'Bitcoin Auto'
+    environment 'test'
+  end
+
+  factory :bitcoin_invoice, class: Spree::BitpayInvoice do
+    association :user 
+    invoice_id INVOICE_ID
+    association :payment_method, factory: :bitcoin_payment_method
+  end
+
+end