spree-split-payments 1.0.0

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/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - ruby-2.1.0
+script:
+  - bundle exec rake test_app
+  - bundle exec rspec .

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,26 @@
+Copyright (c) 2014 Vinsol
+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,96 @@
+Spree Split Payments [![Code Climate](https://codeclimate.com/github/vinsol/spree-split-payments.png)](https://codeclimate.com/github/vinsol/spree-split-payments) [![Build Status](https://travis-ci.org/vinsol/spree-split-payments.png?branch=master)](https://travis-ci.org/vinsol/spree-split-payments)
+=========================
+This extension provides the feature for a spree store to allow user to club payment methods to pay for the order.
+
+Easily configurable from the admin end where one can select which payment methods should be allowed for clubbing and their priorities which can be used while creating payments and displaying them to the user.
+
+Installation
+------------
+
+Add spree-split-payments to your `Gemfile`:
+
+```ruby
+gem 'spree-split-payments'
+```
+
+Bundle your dependencies and run the installation generator:
+
+```shell
+bundle
+bundle exec rails g spree-split-payments:install
+```
+
+Integration
+-----------
+The extension needs a way to find out the maximum amount that can be made via a payment method. To do so it sends a message to the user object as:
+
+```ruby
+#{payment_method.class.name.demodulize.underscore}_for_partial_payments
+
+# for example : for Spree::PaymentMethod::LoyaltyPoints it calls for
+# loyalty_points_for_partial_payments
+# on current_user
+```
+
+So you can either
+
+1) Alias an exising method like
+```ruby
+# models/spree/user_decorator.rb
+alias_method :loyalty_points_for_partial_payments, :loyalty_points_equivalent_currency
+
+# where loyalty_points_equivalent_currency is the method provided by
+# Spree::PaymentMethod::LoyaltyPoints extension.
+```
+
+2) Define a method under user class. For example for Spree::PaymentMethod::LoyaltyPoints)
+```ruby
+#models/spree/user_decorator.rb
+Spree::User.class_eval do
+  ...
+
+  def loyalty_points_for_partial_payments
+    # logic goes here
+  end
+
+  ...
+
+end
+```
+
+Testing
+-------
+
+Be sure to bundle your dependencies and then create a dummy test app for the specs to run against.
+
+```shell
+bundle
+bundle exec rake test_app
+bundle exec rspec spec
+```
+
+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-split-payments/factories'
+```
+
+Contributing
+------------
+
+1. Fork the repo.
+2. Clone your repo.
+3. Run `bundle install`.
+4. Run `bundle exec rake test_app` to create the test application in `spec/test_app`.
+5. Make your changes.
+6. Ensure specs pass by running `bundle exec rspec spec`.
+7. Submit your pull request.
+
+
+Credits
+-------
+
+[![vinsol.com: Ruby on Rails, iOS and Android developers](http://vinsol.com/vin_logo.png "Ruby on Rails, iOS and Android developers")](http://vinsol.com)
+
+Copyright (c) 2014 [vinsol.com](http://vinsol.com "Ruby on Rails, iOS and Android developers"), released under the New MIT License

data/Rakefile

@@ -0,0 +1,15 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+require 'spree/testing_support/extension_rake'
+
+RSpec::Core::RakeTask.new
+
+task :default => [:spec]
+
+desc 'Generates a dummy app for testing'
+task :test_app do
+  ENV['LIB_NAME'] = 'spree-split-payments'
+  Rake::Task['extension:test_app'].invoke
+end

data/app/assets/javascripts/admin/spree-split-payments.js

@@ -0,0 +1 @@
+//= require admin/spree_backend

data/app/assets/javascripts/store/spree-split-payments.js

@@ -0,0 +1,36 @@
+Spree.fill_in_pm_amounts = function() {
+// [TODO] Please extract the logic written below into a function with an appropriate name and call same function here.
+  amountDivs = $("#split-payments-data div");
+  if(amountDivs.length) {
+    for(i = 0; i < amountDivs.length; i++) {
+      $("label.pm-amount[data-pm-id='"+ amountDivs[i].getAttribute('data-pm-id') +"']").html(amountDivs[i].getAttribute('data-pm-amount'));
+    }
+  }
+}
+
+Spree.find_partial_payments_total = function(value) {
+  partial_payment_total = 0
+  selected_partial_methods = $("input[name='order[split_payments][][payment_method_id]']:checked");
+  if(selected_partial_methods.length) {
+    for(i = 0; i < selected_partial_methods.length; i++) {
+      partial_payment_total += parseInt($("#split-payments-data div[data-pm-id='"+ value +"']")[0].getAttribute('data-pm-amount'));
+    }
+  }
+  return partial_payment_total;
+}
+
+$(document).ready(function() {
+
+  Spree.fill_in_pm_amounts();
+  
+  $("input[name='order[split_payments][][payment_method_id]']").click(function() {
+    // [TODO] Please extract the logic written below into a function with an appropriate name and call same function here.
+    // Also break into multiple functions if needed/possible.
+    partial_payment_total = Spree.find_partial_payments_total($(this).val());
+    
+    if(partial_payment_total >= order_balance ) {
+      $(this).attr('checked', false);
+      alert('exceeding order total');
+    }
+  });
+});

data/app/assets/stylesheets/admin/spree-split-payments.css

@@ -0,0 +1,3 @@
+/*
+ *= require admin/spree_backend
+*/

data/app/assets/stylesheets/store/spree-split-payments.css

@@ -0,0 +1,3 @@
+/*
+ *= require store/spree_frontend
+*/

data/app/controllers/spree/checkout_controller_decorator.rb

@@ -0,0 +1,65 @@
+Spree::CheckoutController.class_eval do
+  before_action :insert_payments_using_split_payments,
+                only: :update, if: -> { process_split_payments? }
+
+  private
+    def insert_payments_using_split_payments
+      @order_balance_after_split_payment = @order.outstanding_balance
+
+      params['order']['split_payments'].each do |split_payment|
+        payment_method = Spree::PaymentMethod.supporting_partial_payments.where(id: split_payment['payment_method_id']).first
+        if payment_method
+          payment_amount = find_amount_for_partial_payment_for(payment_method);
+          insert_split_payment_for(split_payment['payment_method_id'], payment_amount) unless payment_amount.zero?
+        end
+      end
+      params['order'].delete('split_payments')
+    end
+
+    def insert_split_payment_for(payment_method_id, amount)
+      params[:order][:payments_attributes].insert(0, 
+        { payment_method_id: payment_method_id,
+          is_partial: true,
+          amount: amount
+        }
+      )
+      @order_balance_after_split_payment -= amount
+    end
+
+    def find_amount_for_partial_payment_for(payment_method)
+      spree_current_user.maximum_partial_payment_for_payment_method(payment_method)
+    end
+
+    # over write this to use outstanding_amount instead of total amount
+    # for payment_attributes amount assignment
+    def object_params
+      # has_checkout_step? check is necessary due to issue described in #2910
+      if @order.has_checkout_step?('payment') && @order.payment?
+        if params[:payment_source].present?
+          source_params = params.delete(:payment_source)[params[:order][:payments_attributes].first[:payment_method_id].underscore]
+
+          if source_params
+            params[:order][:payments_attributes].first[:source_attributes] = source_params
+          end
+        end
+
+        if params[:order][:payments_attributes]
+          params[:order][:payments_attributes].last[:amount] = @order_balance_after_split_payment || @order.outstanding_balance
+        end
+      end
+
+      if params[:order]
+        params[:order].permit(permitted_checkout_attributes)
+      else
+        {}
+      end
+    end
+
+    def payment_step?
+      params[:state] == 'payment'
+    end
+
+    def process_split_payments?
+      payment_step? && params['order']['split_payments']
+    end
+end

data/app/models/spree/order_decorator.rb

@@ -0,0 +1,8 @@
+Spree::Order.class_eval do
+  Spree::Order.state_machine.before_transition :to => :complete, :do => :process_partial_payments
+
+  private
+  def process_partial_payments
+    self.payments.pending.partial.each { |payment| payment.complete }
+  end
+end

data/app/models/spree/payment_decorator.rb

@@ -0,0 +1,13 @@
+Spree::Payment.class_eval do
+  after_create :mark_pending_if_partial, if: :is_partial?
+
+  def self.partial
+    where(is_partial: true)
+  end
+
+  private
+
+  def mark_pending_if_partial
+    self.pend
+  end
+end

data/app/models/spree/payment_method_decorator.rb

@@ -0,0 +1,7 @@
+Spree::PaymentMethod.class_eval do
+  scope :supporting_partial_payments, -> { active.where(for_partial: true).order('partial_priority desc') }
+
+  def self.active
+    where(active: true)
+  end
+end

data/app/models/spree/user_decorator.rb

@@ -0,0 +1,14 @@
+Spree::User.class_eval do
+  # alias should be defined in the app integrating partial payments with
+  # any other payment method
+  # for example for Spree::LoyaltyPoints has a method for user to calculate
+  # amount quivalent to points as loyalty_points_equivalent_currency, so we do
+  # alias_method :loyalty_points_for_partial_payments,
+  #              :loyalty_points_equivalent_currency
+
+  def maximum_partial_payment_for_payment_method(payment_method)
+    send(
+      "#{payment_method.class.name.demodulize.underscore}_for_partial_payments"
+      .to_sym)
+  end
+end

data/app/overrides/add_partial_payment_form_fields_admin.rb

@@ -0,0 +1,25 @@
+# [TODO] 1..5 value in select code should not be hardcoded.
+Deface::Override.new(
+  virtual_path: 'spree/admin/payment_methods/_form',
+  name: 'add partial payment form fields',
+  insert_after: "[data-hook='active']",
+  text: %q{
+    <div data-hook="for_partial" class="field">
+      <%= label_tag nil, Spree.t(:supports_partial_payment) %>
+      <ul>
+        <li>
+          <%= radio_button :payment_method, :for_partial, true %>
+          <%= label_tag nil, Spree.t(:say_yes) %>
+        </li>
+        <li>
+          <%= radio_button :payment_method, :for_partial, false %>
+          <%= label_tag nil, Spree.t(:say_no) %>
+        </li>
+      </ul>
+    </div>
+    <div data-hook="partial_priority" class="field">
+      <%= label_tag nil, Spree.t(:partial_priority) %>
+      <%= select_tag "payment_method[partial_priority]",
+          options_for_select(1..5, @object.partial_priority) %>
+    </div>
+  })

data/app/overrides/add_split_payments_to_payment_form.rb

@@ -0,0 +1,5 @@
+Deface::Override.new(
+  virtual_path: 'spree/checkout/_payment',
+  name: 'add split payments to payment form',
+  insert_top: '#payment-method-fields',
+  partial: 'shared/split_payments')

data/app/views/shared/_split_payments.html.erb

@@ -0,0 +1,22 @@
+<% partial_payment_methods = Spree::PaymentMethod.supporting_partial_payments %>
+<% if partial_payment_methods.present? %>
+  <%= render :partial => '/shared/split_payments_data', :locals => { :payment_methods => partial_payment_methods } %>
+  Club my payment with
+  <table id="split_payment_options">
+  <% partial_payment_methods.each do |payment_method| %>
+    <tr>
+      <td>
+        <label>
+        <%= check_box_tag "order[split_payments][][payment_method_id]", payment_method.id %>
+        <%= Spree.t(payment_method.name) %>
+        </label>
+        (<label class="pm-amount" data-pm-id=<%= payment_method.id %>></label>)
+      </td>
+    </tr>
+  <% end %>
+  </table>
+<% end %>
+<!-- [TODO] No inline JS -->
+<script>
+  var order_balance = <%= current_order.outstanding_balance %>
+</script>

data/app/views/shared/_split_payments_data.html.erb

@@ -0,0 +1,6 @@
+<div id="split-payments-data">
+  <% payment_methods.each do |payment_method| %>
+    <div data-pm-id=<%= payment_method.id %> data-pm-amount=<%= spree_current_user.maximum_partial_payment_for_payment_method(payment_method) %>>
+    </div>
+  <% end %>
+</div>

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-split-payments/engine', __FILE__)
+
+require 'rails/all'
+require 'rails/engine/commands'

data/config/locales/en.yml

@@ -0,0 +1,8 @@
+# Sample localization file for English. Add more files in this directory for other locales.
+# See https://github.com/svenfuchs/rails-i18n/tree/master/rails%2Flocale for starting points.
+
+en:
+  hello: "Hello world"
+  spree:
+    supports_partial_payment: "Use it for partial payments"
+    partial_priority: "Set Priority"

data/config/routes.rb

@@ -0,0 +1,3 @@
+Spree::Core::Engine.routes.draw do
+  # Add your extension routes here
+end

data/db/migrate/20140318063048_add_partial_payment_fields_to_spree_payment_method.rb

@@ -0,0 +1,6 @@
+class AddPartialPaymentFieldsToSpreePaymentMethod < ActiveRecord::Migration
+  def change
+    add_column :spree_payment_methods, :for_partial, :boolean, default: false
+    add_column :spree_payment_methods, :partial_priority, :integer, default: 0
+  end
+end

data/db/migrate/20140318063049_add_is_partial_to_spree_payment.rb

@@ -0,0 +1,5 @@
+class AddIsPartialToSpreePayment < ActiveRecord::Migration
+  def change
+    add_column :spree_payments, :is_partial, :boolean, default: false
+  end
+end

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

@@ -0,0 +1,26 @@
+module SpreeSplitPayments
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+
+      class_option :auto_run_migrations, type: :boolean, default: false
+
+      def add_javascripts
+        append_file 'app/assets/javascripts/store/all.js', "//= require store/spree-split-payments\n"
+        append_file 'app/assets/javascripts/admin/all.js', "//= require admin/spree-split-payments\n"
+      end
+
+      def add_stylesheets
+        inject_into_file 'app/assets/stylesheets/store/all.css', " *= require store/spree-split-payments\n", before: /\*\//, verbose: true
+        inject_into_file 'app/assets/stylesheets/admin/all.css', " *= require admin/spree-split-payments\n", before: /\*\//, verbose: true
+      end
+
+      def add_migrations
+        run 'bundle exec rake railties:install:migrations FROM=spree_split_payments'
+      end
+
+      def run_migrations
+        run 'bundle exec rake db:migrate'
+      end
+    end
+  end
+end

data/lib/spree-split-payments.rb

@@ -0,0 +1,2 @@
+require 'spree_core'
+require 'spree_split_payments/engine'

data/lib/spree_split_payments/engine.rb

@@ -0,0 +1,23 @@
+module SpreeSplitPayments
+  class Engine < Rails::Engine
+    require 'spree/core'
+    isolate_namespace Spree
+    engine_name 'spree_split_payments'
+
+    config.autoload_paths += %W(#{config.root}/lib)
+
+    # use rspec for tests
+    config.generators do |g|
+      g.test_framework :rspec
+    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
+      Spree::PermittedAttributes.payment_attributes << :is_partial
+    end
+
+    config.to_prepare &method(:activate).to_proc
+  end
+end

data/lib/spree_split_payments/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_split_payments/factories'
+end

data/spec/controllers/spree/checkout_controller_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+
+describe Spree::CheckoutController do
+  let(:user) { mock_model(Spree.user_class) }
+  let(:order) { Spree::Order.new }
+  let(:payment_method_partial_payment) { 10 }
+
+  before(:each) do
+    allow(controller).to receive(:spree_current_user).and_return(user)
+    allow(controller).to receive(:authorize!).and_return(true)
+    allow(order).to receive(:checkout_allowed?).and_return(true)
+    allow(controller).to receive(:load_order_with_lock).and_return(true)
+    user.stub(:last_incomplete_spree_order).and_return(order)
+    allow(controller).to receive(:ensure_order_not_completed).and_return(true)
+    allow(controller).to receive(:ensure_valid_state).and_return(true)
+    controller.instance_variable_set(:@order, order)
+    @payment_method = mock_model(Spree::PaymentMethod,
+                                 type: 'Spree::PaymentMethod::Check')
+    allow(Spree::PaymentMethod).to receive(:supporting_partial_payments).and_return(Spree::PaymentMethod)
+    # allow(Spree::PaymentMethod).to receive(:where).with({:deleted_at=>nil}).and_return(Spree::PaymentMethod)
+    allow(Spree::Payment.any_instance).to receive(:mark_pending_if_partial).and_return(true)
+    allow(order).to receive(:update_attributes).and_return(false)
+    allow(order).to receive(:outstanding_balance).and_return(100)
+  end
+
+  describe '#insert_payments_using_split_payments' do
+    def send_request(params = {})
+      put :update, params.merge!(use_route: 'spree')
+    end
+
+    context 'when state is not payment' do
+      it { controller.should_not_receive(:insert_payments_using_split_payments) }
+      after do
+        send_request(
+          order: {
+            payments_attributes: [{ payment_method_id: '1' }] },
+          state: 'delivery')
+      end
+    end
+
+    context 'when state is payment but without any split payment' do
+      it { controller.should_not_receive(:insert_payments_using_split_payments) }
+      after do
+        send_request(
+          order: {
+            payments_attributes: [{ payment_method_id: '1' }] },
+          state: 'payment')
+      end
+    end
+
+    context 'when state is payment and split payment attributes present' do
+      context 'payment method not found' do
+        it { expect(Spree::PaymentMethod).to receive(:supporting_partial_payments).and_return(Spree::PaymentMethod) } 
+        it { Spree::PaymentMethod.should_receive(:where).with(id: '1').and_return([]) }
+        it { expect(controller).to_not receive(:find_amount_for_partial_payment_for) }
+      end
+
+      context 'payment method is found' do
+        before do
+          allow(Spree::PaymentMethod).to receive(:where).with(id: '1').and_return([@payment_method])
+          allow(user).to receive(:maximum_partial_payment_for_payment_method).with(@payment_method).and_return(payment_method_partial_payment)
+          # allow(controller).to receive(:insert_split_payment_for).with('1', payment_method_partial_payment).and_return(true)
+        end
+        
+        it { expect(Spree::PaymentMethod).to receive(:where).with(id: '1').and_return([@payment_method]) }  
+        it { expect(order).to receive(:outstanding_balance).and_return(order.total) }
+
+        context 'when payment amount is not zero' do
+          it { expect(user).to receive(:maximum_partial_payment_for_payment_method).with(@payment_method).and_return(payment_method_partial_payment) }
+          it { expect(controller).to receive(:insert_split_payment_for).with('1', payment_method_partial_payment).and_return(true) }
+        end
+
+        context 'when payment amount is zero' do
+          before { allow(user).to receive(:maximum_partial_payment_for_payment_method).with(@payment_method).and_return(0) }
+          
+          it { expect(user).to receive(:maximum_partial_payment_for_payment_method).with(@payment_method).and_return(0) }
+          it { expect(controller).to_not receive(:insert_split_payment_for) }
+        end
+
+        context '#split payment inserted and amount is updated for last payment' do
+          before do
+            allow(order).to receive(:has_checkout_step?).and_return(true)
+            allow(order).to receive(:payment?).and_return(true)
+          end
+
+          it { expect(order).to receive(:update_attributes).with({
+            "payments_attributes" => [
+              {"amount"=>10, "payment_method_id"=>"1", "is_partial"=>true},
+              {"amount"=>90, "payment_method_id"=>"1"}
+            ]}).and_return(false) }
+        end
+      end
+
+      after do
+        send_request(
+          order: {
+            split_payments: [{ payment_method_id: '1' }],
+            payments_attributes: [{ payment_method_id: '1' }]},
+          state: 'payment')
+      end
+    end
+  end
+
+  describe '#object_params' do
+    def send_request(params = {})
+      put :update, params.merge!(use_route: 'spree')
+    end
+    before do
+      allow(order).to receive(:has_checkout_step?).and_return(true)
+      allow(order).to receive(:payment?).and_return(true)
+    end
+
+    it { expect(order).to receive(:outstanding_balance).and_return(order.total) }
+
+    after do
+      send_request(
+        order: {
+          payments_attributes: [{ payment_method_id: '1' }] },
+        state: 'payment')
+    end
+  end
+end

data/spec/models/spree/order_decorator_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Spree::Order do
+  let(:order) { Spree::Order.create!(:email => 'test-account@myweb.com') }
+
+  describe 'process_partial_payments' do
+    before do
+      @payment = order.payments.build
+      @payments = [@payment]
+      allow(order).to receive(:payments).and_return(@payments)
+      allow(@payments).to receive(:pending).and_return(@payments)
+      allow(@payments).to receive(:partial).and_return(@payments)
+    end
+
+    it { expect(@payments).to receive(:pending).and_return(@payments) }
+    it { expect(@payments).to receive(:partial).and_return(@payments) }
+    it { expect(@payment).to receive(:complete).and_return(true) }
+
+    after { order.send(:process_partial_payments) }
+  end
+
+  context 'state machine' do
+    it { Spree::Order.state_machine.callbacks[:before].select { |callback| callback.instance_eval{@methods}.include?(:process_partial_payments) && callback.branch.state_requirements.any? {|req| req[:to].values.include?(:complete)} }.should_not be_blank }
+  end
+end

data/spec/models/spree/payment_decorator_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe 'Spree::Payment' do
+  let(:order) { Spree::Order.create! }
+  context 'after create callback' do
+    context 'for partial payments' do
+      before do
+        @payment = order.payments.new(is_partial: true)
+        allow(@payment).to receive(:pend).and_return(true)
+      end
+
+      it 'calls for pend on save' do
+        expect(@payment).to receive(:pend).and_return(true)
+        @payment.save!
+      end
+    end
+
+    context 'for non-partial payments' do
+      before { @payment = order.payments.new }
+
+      it 'calls for pend on save' do
+        expect(@payment).to_not receive(:pend)
+        @payment.save!
+      end
+    end
+  end
+end

data/spec/models/spree/payment_method_decorator_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe 'Spree::PaymentMethod' do
+  context 'scope' do
+    before :all do
+      @first_partial_method = Spree::PaymentMethod.create!(
+                                        name: 'test_method',
+                                        for_partial: true,
+                                        partial_priority: 1)
+      @second_partial_method = Spree::PaymentMethod.create!(
+                                        name: 'test_method_1',
+                                        for_partial: true,
+                                        partial_priority: 2)
+      @test_method = Spree::PaymentMethod.create!(
+                                        name: 'test_method_2')
+      @inactive_partial_method = Spree::PaymentMethod.create!(
+                                        name: 'test_method_1',
+                                        for_partial: true,
+                                        active: false)
+      @inactive_method = Spree::PaymentMethod.create!(
+                                        name: 'test_method_1',
+                                        active: false)
+      @partial_methods = Spree::PaymentMethod
+                                 .supporting_partial_payments
+      @active_methods = Spree::PaymentMethod.active
+    end
+
+    it 'supporting_partial_payments:is_partial? and active?' do
+      @partial_methods.to_a.should eq([@second_partial_method,
+                                       @first_partial_method])
+
+      @partial_methods.should_not include(@test_method,
+                                          @inactive_method,
+                                          @inactive_partial_method)
+    end
+
+    it 'active:active?' do
+      @active_methods.should include(@first_partial_method,
+                                     @second_partial_method,
+                                     @test_method)
+      @active_methods.should_not include(@inactive_method,
+                                         @inactive_partial_method)
+    end
+  end
+end

data/spec/models/spree/user_decorator_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe 'Spree::User' do
+  let(:user) { Spree::User.new }
+  let(:order) { Spree::Order.new }
+  describe 'maximum_partial_payment_for_payment_method' do
+    before do
+      @method = Spree::PaymentMethod.create!(name: 'test_method',
+                                             type: 'Spree::Gateway::Bogus')
+      allow(user).to receive(:bogus_for_partial_payments).and_return(10)
+    end
+
+    it 'calls for method corresponding to payment method class name' do
+      expect(user).to receive(:bogus_for_partial_payments).and_return(10)
+      user.maximum_partial_payment_for_payment_method(@method)
+          .should eq(10)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,62 @@
+# This file is copied to spec/ when you run 'rails generate rspec:install'
+ENV["RAILS_ENV"] ||= 'test'
+require File.expand_path("../dummy/config/environment", __FILE__)
+require 'rspec/rails'
+
+require 'rubygems'
+require 'bundler/setup'
+require 'database_cleaner'
+
+# require 'spree/testing_support/url_helpers'
+
+# # Requires factories defined in lib/spree_spree-split-payments/factories.rb
+# require 'spree_split_payments/factories'
+
+RSpec.configure do |config|
+  # config.include FactoryGirl::Syntax::Methods
+
+  # == URL Helpers
+  #
+  # Allows access to Spree's routes in specs:
+  #
+  # visit spree.admin_path
+  # current_path.should eql(spree.products_path)
+  # config.include Spree::TestingSupport::UrlHelpers
+
+  # == Mock Framework
+  #
+  # If you prefer to use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+  config.mock_with :rspec
+  config.color = true
+
+  # Remove this line if you're not using ActiveRecord or ActiveRecord fixtures
+  config.fixture_path = "#{::Rails.root}/spec/fixtures"
+
+  # Capybara javascript drivers require transactional fixtures set to false, and we use DatabaseCleaner
+  # to cleanup after each test instead.  Without transactional fixtures set to false the records created
+  # to setup a test will be unavailable to the browser, which runs under a seperate server instance.
+  config.use_transactional_fixtures = false
+
+  # Ensure Suite is set to use transactions for speed.
+  config.before :suite do
+    DatabaseCleaner.strategy = :transaction
+    DatabaseCleaner.clean_with :truncation
+  end
+
+  # Before each spec check if it is a Javascript test and switch between using database transactions or not where necessary.
+  config.before :each do
+    DatabaseCleaner.strategy = example.metadata[:js] ? :truncation : :transaction
+    DatabaseCleaner.start
+  end
+
+  # After each spec clean the database.
+  config.after :each do
+    DatabaseCleaner.clean
+  end
+
+  config.fail_fast = ENV['FAIL_FAST'] || false
+end

data/spree-split-payments.gemspec

@@ -0,0 +1,25 @@
+# encoding: UTF-8
+Gem::Specification.new do |s|
+  s.platform    = Gem::Platform::RUBY
+  s.name        = 'spree-split-payments'
+  s.version     = '1.0.0'
+  s.required_ruby_version = '>= 1.9.3'
+
+  s.author    = 'Manish Kangia'
+  s.email     = 'info@vinsol.com'
+  s.homepage  = 'http://vinsol.com'
+
+  s.summary   = 'Provides the feature for a Spree store to allow user to club payment methods to pay for the order'
+  s.license   = 'MIT'
+
+  s.files       = `git ls-files`.split("\n")
+  s.require_path = 'lib'
+  s.requirements << 'none'
+
+  s.add_dependency 'spree_core', '~> 2.1.0'
+
+  s.add_development_dependency 'database_cleaner'
+  s.add_development_dependency 'rspec-rails',  '~> 2.13'
+  s.add_development_dependency 'simplecov'
+  s.add_development_dependency 'sqlite3'
+end

metadata

@@ -0,0 +1,174 @@
+--- !ruby/object:Gem::Specification 
+name: spree-split-payments
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Manish Kangia
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2014-04-01 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: spree_core
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 2
+        - 1
+        - 0
+        version: 2.1.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: database_cleaner
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec-rails
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 25
+        segments: 
+        - 2
+        - 13
+        version: "2.13"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: simplecov
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: sqlite3
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+description: 
+email: info@vinsol.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- app/assets/javascripts/admin/spree-split-payments.js
+- app/assets/javascripts/store/spree-split-payments.js
+- app/assets/stylesheets/admin/spree-split-payments.css
+- app/assets/stylesheets/store/spree-split-payments.css
+- app/controllers/spree/checkout_controller_decorator.rb
+- app/models/spree/order_decorator.rb
+- app/models/spree/payment_decorator.rb
+- app/models/spree/payment_method_decorator.rb
+- app/models/spree/user_decorator.rb
+- app/overrides/add_partial_payment_form_fields_admin.rb
+- app/overrides/add_split_payments_to_payment_form.rb
+- app/views/shared/_split_payments.html.erb
+- app/views/shared/_split_payments_data.html.erb
+- bin/rails
+- config/locales/en.yml
+- config/routes.rb
+- db/migrate/20140318063048_add_partial_payment_fields_to_spree_payment_method.rb
+- db/migrate/20140318063049_add_is_partial_to_spree_payment.rb
+- lib/generators/spree_split_payments/install/install_generator.rb
+- lib/spree-split-payments.rb
+- lib/spree_split_payments/engine.rb
+- lib/spree_split_payments/factories.rb
+- spec/controllers/spree/checkout_controller_spec.rb
+- spec/models/spree/order_decorator_spec.rb
+- spec/models/spree/payment_decorator_spec.rb
+- spec/models/spree/payment_method_decorator_spec.rb
+- spec/models/spree/user_decorator_spec.rb
+- spec/spec_helper.rb
+- spree-split-payments.gemspec
+homepage: http://vinsol.com
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 53
+      segments: 
+      - 1
+      - 9
+      - 3
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: 
+- none
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Provides the feature for a Spree store to allow user to club payment methods to pay for the order
+test_files: []
+