spree_bitpay 1.0.2 → 2.0.0

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

@@ -1,3 +0,0 @@
-/* 
- *= require spree/backend
-*/

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

@@ -1,58 +0,0 @@
-/* 
- *= require spree/frontend
-*/
-// Bitpay Payment Method styling
-
-// No idea why this element is needed but it seems the first entry is ignored??
-// TODO: Is this really needed?
-
-#throwaway {
-	width: 20px;
-}
-
-#bitpay_modal_content {
-	padding:40px;
-	background-color: #FFF;
-}
-
-#bitpay_invoice_iframe {
-	width: 500px;
-	//height: 150px;
-	border: 1px solid #d9d9db;
-	overflow: hidden;
-	padding:20px;
-	max-width: 100%;
-}
-
-
-#bitpay_view_invoice_iframe {
-	width: 542px;
-	//height: 150px;
-	border: 1px solid #d9d9db;
-	overflow: hidden;
-	padding:20px;
-	max-width: 100%;
-}
-
-#bitpay_checkout_guidance {
-	text-align: center;
-	margin: auto;
-}
-
-#bitpay_payment_buttons {
-	padding-top: 10px;
-	text-align: center;
-}
-
-a.button.disabled {
-	background-color: #727276;
-	border-color: #59595c;
-	color: #CCC;
-	opacity: .65;
-	pointer-events: none;
-}
-
-.bitpay_invoice_details {
-	padding-top: 20px;
-	padding-bottom: 20px;
-}

data/app/controllers/spree/bitpay_controller.rb

@@ -1,243 +0,0 @@
-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
-      
-      payment = order.get_bitpay_payment
-
-      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/order_decorator.rb

@@ -1,17 +0,0 @@
-Spree::Order.class_eval do
-  self.state_machine.before_transition :to => :confirm, :do => :validate_bitpay_payment
-
-  def validate_bitpay_payment
-    states = payments.map(&:state)
-    payments.each do |payment|
-      payment.failure if payment.state == 'processing'
-    end if (states.include?('checkout') && states.include?('processing'))
-  end
-
-  def get_bitpay_payment
-    checkout = payments.select{|payment| payment.state == 'checkout'}
-    processing = payments.select{|payment| payment.state == 'processing'}
-    return checkout.last if checkout.any?
-    return processing.last if processing.any?
-  end
-end

data/app/models/spree/bitpay_invoice.rb

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

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

@@ -1,55 +0,0 @@
-<!-- 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 %>
-
-