servicemerchant 0.1.0

data/recurring_billing/test/unit/authorize_net_gateway_class_test.rb

@@ -0,0 +1,42 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class AuthorizeNetGatewayTest < Test::Unit::TestCase
+  
+  def setup
+    credentials = fixtures(:authorize_net)
+    assert @gw = RecurringBilling::AuthorizeNetGateway.new(credentials.update({:is_test => true}))
+    assert_equal @gw.name, 'Authorize.net'
+    @card = credit_card()
+  end
+
+  def test_correct_update?
+    #def correct_update?(billing_id, amount, card, payment_options, recurring_options)
+    subscr_id = 'SOMERANDOMID'
+    assert_raise StandardError do; @gw.correct_update?(subscr_id, nil, @card, nil, {:start_date => Date.today + 1}); end
+    assert_nothing_thrown do;@gw.correct_update?(subscr_id, 1, @card, nil, nil);end
+    assert_nothing_thrown do;@gw.correct_update?(subscr_id, 100, @card, nil, {});end
+    
+  end
+  
+  def test_transform_dates
+    def d(string);return Date.parse(string);end
+    def h(a,b,c,d);return {:interval=>{:length=>a, :unit=>b}, :duration=>{:start_date=>c, :occurrences=>d}};end
+    
+    #syntax is: transform_dates(start_date, interval, occurrences, end_date)
+    assert_raise ArgumentError do; @gw.transform_dates(d('2008/01/01'), '5m', nil, nil); end
+    assert_raise ArgumentError do; @gw.transform_dates(d('2008/01/01'), '5m', 5, d('2009/01/01')); end
+    assert_raise ArgumentError do; @gw.transform_dates(d('2008/01/01'), 'm', 1, nil); end
+    assert_raise ArgumentError do; @gw.transform_dates(d('2008/01/01'), '0.5m', 1, nil); end
+    assert_raise ArgumentError do; @gw.transform_dates(d('2008/01/01'), '1 year', 1, nil); end
+    assert_raise ArgumentError do; @gw.transform_dates(d('2008/01/01'), '8', 1, nil); end
+    assert_raise ArgumentError do; @gw.transform_dates(d('2008/01/01'), '5m', -1, nil); end
+    assert_raise ArgumentError do; @gw.transform_dates(d('2008/01/01'), '5m', nil, d('2007/12/31')); end
+    
+    assert_equal @gw.transform_dates(d('2008/01/01'), '5m', 7, nil), h(5,:months,d('2008/01/01'),7)
+    assert_equal @gw.transform_dates(d('2008/01/01'), '3 d', nil, d('2008/01/19')), h(3,:days,d('2008/01/01'),7)
+    assert_equal @gw.transform_dates(d('2008/01/01'), '3d', nil, d('2008/01/21')), h(3,:days,d('2008/01/01'),7)
+    assert_equal @gw.transform_dates(d('2008/01/01'), '8w', 13, nil), h(56,:days,d('2008/01/01'),13)
+    assert_equal @gw.transform_dates(d('2008/01/01'), '1y', nil, d('2010/12/01')), h(12,:months,d('2008/01/01'),3)
+  end
+
+end

data/recurring_billing/test/unit/paypal_gateway_class_test.rb

@@ -0,0 +1,23 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class PaypalGatewayTest < Test::Unit::TestCase
+
+  def setup
+    cred = fixtures(:paypal)
+    assert @gw = RecurringBilling::PaypalGateway.new(cred.update({:is_test=>true}))
+    assert_equal @gw.name, 'PayPal Website Payments Pro (US)'
+    @card = credit_card()
+  end
+
+  def test_true
+  end
+
+#  def test_correct_update?
+#    #def correct_update?(billing_id, amount, card, payment_options, recurring_options)
+#    subscr_id = 'SOMERANDOMID'
+#    assert_raise StandardError do; @gw.correct_update?(subscr_id, nil, @card, nil, {:start_date => Date.today + 1}); end
+#    assert_nothing_thrown do;@gw.correct_update?(subscr_id, 1, @card, nil, nil);end
+#    assert_nothing_thrown do;@gw.correct_update?(subscr_id, 100, @card, nil, {});end
+#  end
+
+end

data/recurring_billing/test/unit/recurring_billing_gateway_class_test.rb

@@ -0,0 +1,35 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class RecurringBillingGatewayTest < Test::Unit::TestCase
+
+  def perform_generic_test(gateway)
+    credentials = fixtures(gateway)
+    assert gw = RecurringBilling::RecurringBillingGateway.get_instance(credentials)
+  end
+
+  # Checking separate_create_update_params_from_options method  
+  def test_separate_create_update_params_from_options
+    cc = credit_card()
+    payment_options = {
+          :subscription_name => 'Test Subscription 1337',
+          :order => {:invoice_number => '000000'}
+          }
+    recurring_options = {
+          :start_date => Date.today + 1,
+          :end_date => Date.today + 290,
+          :interval => '1m'
+          }
+    all_options = {}.update({:card => cc}).update(payment_options).update(recurring_options)
+    separate_options = RecurringBilling::RecurringBillingGateway.separate_create_update_params_from_options(all_options)
+    assert_equal separate_options, {:amount => nil, :card => cc, :payment_options => payment_options, :recurring_options => recurring_options}
+  end
+
+  def test_paypal
+    perform_generic_test(:paypal)
+  end
+
+  def test_authorize_net
+    perform_generic_test(:authorize_net)
+  end
+  
+end

data/recurring_billing/test/unit/utils_test.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class UtilsTest < Test::Unit::TestCase
+  def test_months_between
+    def d(string);return Date.parse(string);end
+    
+    assert months_between(d("2008/10/01"), d("2008/10/01")), 0
+    assert months_between(d("2008/10/02"), d("2008/10/01")), 0
+    assert months_between(d("2008/11/01"), d("2008/10/02")), 0
+    assert months_between(d("2008/01/01"), d("2007/12/31")), 0
+    assert months_between(d("2008/11/01"), d("2008/10/01")), 1
+    assert months_between(d("2008/02/01"), d("2007/05/01")), 9
+    assert months_between(d("2008/02/14"), d("2007/05/01")), 9
+    assert months_between(d("2008/02/02"), d("2007/05/13")), 8
+  end
+
+end

data/subscription_management/Rakefile

@@ -0,0 +1,29 @@
+require 'rake'
+require File.dirname(__FILE__) + '/tasks/schema.rb'
+
+
+require 'rake/testtask'
+namespace :test do
+
+  Rake::TestTask.new(:remote_sm) do |t|
+    t.pattern = 'test/remote/**/*_test.rb'
+    t.ruby_opts << '-rubygems'
+    t.verbose = true
+  end
+
+  desc "Run all remote tests"
+  task :remote => [:remote_sm]
+
+  Rake::TestTask.new(:unit_sm) do |t|
+    t.pattern = 'test/unit/**/*_test.rb'
+    t.ruby_opts << '-rubygems'
+    t.verbose = true
+  end
+
+  desc "Run all unit tests"
+  task :unit => [:unit_sm]
+
+  desc "Run all tests"
+  task :all => [:unit_sm, :remote_sm]
+ 
+end

data/subscription_management/lib/models/subscription.rb

@@ -0,0 +1,9 @@
+class Subscription < ActiveRecord::Base
+  has_many :subscription_profiles
+  has_many :recurring_payment_profiles, :through => :subscription_profiles
+
+  # Returns billing amount (sum of net amount + taxes) 
+  def billing_amount
+    self.net_amount + self.taxes_amount
+  end
+end

data/subscription_management/lib/models/subscription_profile.rb

@@ -0,0 +1,4 @@
+class SubscriptionProfile < ActiveRecord::Base
+belongs_to :subscription
+belongs_to :recurring_payment_profile
+end

data/subscription_management/lib/subscription_management.rb

@@ -0,0 +1,326 @@
+require 'yaml'
+require File.dirname(__FILE__) + '/../../recurring_billing/lib/recurring_billing'
+require File.dirname(__FILE__) + '/../../tracker/tracker'
+require 'rubygems'
+require 'active_support/inflector'
+
+#module SubscriptionManagement
+
+  # This class allows handling of user subscriptions for given merchant service. See {PROJECT_ROOT}/demo.rb for usage example.
+  class SubscriptionManagement
+    attr_accessor :all_tariff_plans, :all_taxes, :tariff_plans_namespace, :all_gateways, :gateway
+
+    # Constructs new SubscriptionManagement object
+    #
+    # Optional +options+ hash may include:
+    #
+    # definition of tariff plan config by config file name
+    # - :tariff_plans_config - string defining name of YML file to read tariff plan configuration from
+    # definition of tariff plan config by specifying tariff plans and its namespace directly (only if :tariff_plans_config is not present)
+    # - :all_tariff_plans - hash containing tariff plans
+    # - :tariff_plans_namespace - string defining namespace for given tariff plans
+    # definition of tax config by config file name
+    # - :taxes_config - string defining name of YML file to read taxes configuration from
+    # definition of tax config by specifying tariff plans and its namespace directly (only if :taxes_config is not present)
+    # - :all_taxes - hash containing taxes
+    # definition of gateways config by config file name
+    # - :gateways_config - string defining name of YML file to read gateways configuration from
+    # definition of tax config by specifying tariff plans and its namespace directly (only if :gateways_config is not present)
+    # - :all_gateways - hash containing gateways
+    # definition of default gateway
+    # - :gateway - Symbol or string containing gateway name  
+    def initialize(options={})
+      if options[:tariff_plans_config]
+        @all_tariff_plans = SubscriptionManagement.get_all_tariff_plans(options[:tariff_plans_config])
+        @tariff_plans_namespace = File.basename(options[:tariff_plans_config], '.yml').downcase.camelize
+      else
+        if options[:all_tariff_plans]
+          @all_tariff_plans = options[:all_tariff_plans]
+        end
+        if options[:tariff_plans_namespace]
+          @tariff_plan_namespace = options[:tariff_plans_namespace]
+        end
+      end
+
+      if options[:taxes_config]
+        @all_taxes = SubscriptionManagement.get_all_taxes(options[:taxes_config])
+      elsif options[:taxes]
+        @all_taxes = options[:all_taxes]
+      end
+
+      if options[:gateways_config]
+        @all_gateways = SubscriptionManagement.get_gateway_settings(options[:gateways_config])
+      elsif options[:all_gateways]
+        @all_gateways = options[:all_gateways]
+      end
+
+      if [String, Symbol].include? options[:gateway].class
+        @gateway = @all_gateways[options[:gateway].to_sym]
+      elsif options[:gateway].class == Hash
+        @gateway = options[:gateway]
+      end
+
+      return self
+    end
+
+    # Returns the most applicable identifier of tax area settings available for given country and state (instance)
+    def get_applicable_taxes_id(country, state)
+      return SubscriptionManagement.get_taxes_id(@all_taxes, country, state)
+    end
+
+    # Subscribe account for tariff plan, specified in "all_tariff_plans" property of an instance
+    #
+    # options hash should/may include following keys:
+    #   :account_id
+    #   :account_country
+    #   :account_state
+    #   :tariff_plan
+    #   :start_date
+    #   :quantity
+    #   :end_date
+    def subscribe(options)
+      subscription = Subscription.new
+      subscription.account_id=options[:account_id]
+      subscription.tariff_plan_id = options[:tariff_plan]
+      subscription.quantity = options[:quantity]
+
+
+      # Set tariff-related fields
+      tariff = @all_tariff_plans[subscription.tariff_plan_id]
+      raise ArgumentError, 'Invalid tariff given: %s' % subscription.tariff_plan_id if tariff.nil?
+      subscription.currency = tariff["currency"]
+      subscription.periodicity = tariff["payment_term"]["periodicity"]
+
+      subscription.starts_on = options[:start_date] + tariff["payment_term"]["trial_days"]
+      subscription.ends_on = options[:end_date]
+
+      # Set tax- and payment-related fields
+      subscription.taxes_id = get_applicable_taxes_id(options[:account_country], options[:account_state])
+      total_tax = @all_taxes[subscription.taxes_id]["taxes"].inject(0){|sum,item| sum + item["rate"]}   # sum all taxes
+      subscription.net_amount = subscription.quantity * tariff["price"]
+      subscription.taxes_amount = subscription.net_amount * total_tax
+
+      subscription.status = 'pending'
+      subscription.save
+
+      return subscription.id
+    end
+
+    # Proceed subscription payment through specified payment gateway
+    def pay_for_subscription(subscription_id, card, payment_options)
+      subscription = Subscription.find_by_id(subscription_id)
+
+      gw = RecurringBilling::RecurringBillingGateway.get_instance(@gateway)
+      tariff = @all_tariff_plans[subscription.tariff_plan_id]
+      recurring_options = {
+              :start_date => subscription.starts_on,
+              :trial_days => tariff['payment_term']['trial_days'],
+              :end_date => subscription.ends_on,
+              :interval => tariff['payment_term']['periodicity']
+              }
+
+      if payment_options[:subscription_name].nil?
+        payment_options[:subscription_name] = @tariff_plans_namespace+': '+tariff['service']['name']
+      end
+
+      payment_options[:taxes_amount_included] = Money.new(subscription.taxes_amount,subscription.currency)
+
+      gateway_id = gw.create(Money.new(subscription.billing_amount, subscription.currency), card, payment_options, recurring_options)
+      if !gateway_id.nil?
+        sp = SubscriptionProfile.new
+        sp.subscription_id = subscription.id
+        sp.recurring_payment_profile_id = RecurringPaymentProfile.find_by_gateway_reference(gateway_id).id
+        sp.save
+        subscription.status = 'ok'
+        subscription.save
+      else
+        raise StandardError, 'Recurring payment creation error: ' + gw.last_response.message
+      end
+    end
+
+    # Update subscription through specified payment gateway
+    def update_subscription(subscription_id, options)
+      profile = get_active_profile(subscription_id)
+      gw = RecurringBilling::RecurringBillingGateway.get_instance(@gateway)
+      unless new_gateway_reference = gw.update_or_recreate(profile.gateway_reference, options)
+        raise StandardError, 'Cannot update subscription through gateway: ' + gw.last_response.message
+      end
+
+      unless new_gateway_reference == profile.gateway_reference
+        sp = SubscriptionProfile.new
+        sp.subscription_id = subscription_id
+        sp.recurring_payment_profile_id = RecurringPaymentProfile.find_by_gateway_reference(new_gateway_reference).id
+        sp.save
+      end
+    end
+
+    # Gets active profile for given subscription_id
+    def get_active_profile(subscription_id)
+      raise StandardError, "Subscription with ID #{subscription_id} not found" if (subscription = Subscription.find_by_id(subscription_id)).nil?
+      raise StandardError, "Subscription with ID #{subscription_id} is inactive and cannot thus have active profiles" unless subscription.status == 'ok'
+
+      if (profile = subscription.recurring_payment_profiles.find(:first, :conditions => [ "status != 'deleted'"])).nil?
+        raise StandardError, "Cannot find any active profiles for subscription: #{subscription_id}"
+      end
+
+      return profile
+    end
+
+    # Checks if given subscription could be updated (re-create would be needed otherwize)
+    def update_possible?(subscription_id, options)
+      begin
+        gw = RecurringBilling::RecurringBillingGateway.get_instance(@gateway)
+        return gw.can_update?(get_active_profile(subscription_id).gateway_reference, options) ? true : false
+      rescue
+        return false
+      end
+    end
+
+    #Cancel subscription (specified by SUBSCRIPTION_ID)
+    def unsubscribe(subscription_id)
+       raise StandardError, "Subscription with ID #{subscription_id} not found" if (subscription = Subscription.find_by_id(subscription_id)).nil?
+       if subscription.status == 'ok' && !(profile = subscription.recurring_payment_profiles.find(:first, :conditions => [ "status != 'deleted'"])).nil?
+          gw = RecurringBilling::RecurringBillingGateway.get_instance(@gateway)
+          raise StandardError, 'Cannot cancel subscription through gateway: ' + gw.last_response.message unless gw.delete(profile.gateway_reference)
+       end
+       subscription.status = 'canceled'
+       subscription.save
+    end
+
+    #Get available features provided by given subscription (specified by SUBSCRIPTION_ID)
+    def get_features(subscription_id)
+      return {} if (subscription = Subscription.find_by_id(subscription_id)).nil? && (subscription.status != 'ok')
+      @all_tariff_plans[subscription.tariff_plan_id]['service']['features']
+    end
+
+    def get_invoice_data(invoice_id) #:nodoc:
+      transaction = Transaction.find invoice_id
+      profile = transaction.recurring_payment_profile
+
+      if transaction.money != profile.money
+        raise NotImplementedError, 'Transaction payment cannot differ from recurring payment'
+      end
+
+      subscription = SubscriptionProfile.find(:first, :conditions => ['recurring_payment_profile_id = ?', profile]).subscription
+      tariff = @all_tariff_plans[subscription.tariff_plan_id]
+      service_name = '%s %s(%s)' % [
+        tariff['service']['name'],
+        (subscription.quantity == 1 ? '' : 'x%s '% subscription.quantity),
+        SubscriptionManagement.format_periodicity(tariff['payment_term']['periodicity']).gsub('each','per')
+        ]
+      {
+        :billing_account => subscription.account_id,
+        :service_name => service_name,
+        :net_amount => profile.net_money_formatted,
+        :taxes_amount => profile.taxes_money_formatted,
+        :total_amount => profile.money_formatted,
+        :taxes_comment => @all_taxes[subscription.taxes_id]["name"],
+
+        :date => transaction.created_at,
+        :number => transaction.id,
+        :transaction_gateway => profile.gateway,
+        :transaction_id => transaction.gateway_reference,
+        :transaction_amount => transaction.money_formatted
+      }
+    end
+
+    class << self
+
+      # Returns whole contents of given tariff config file (by CONFIG_NAME filename)
+      def read_tariff_config(config_name)
+        return YAML.load([File.read('%s/presets.yml' % File.dirname(config_name)), File.read(config_name)].join("\n"))
+      end
+
+      # Retrieves tariff settings from given file (by CONFIG_NAME filename)
+      def get_all_tariff_plans(config_name)
+        return read_tariff_config(config_name)[File.basename(config_name, '.yml')]['tariff_plans']
+      end
+
+      # Reads tax config from given file (by CONFIG_NAME filename)
+      def get_all_taxes(config_name)
+        return YAML.load(File.read(config_name))['taxes']
+      end
+
+      # Reads gateway settings from given file (by CONFIG_NAME filename)
+      def get_gateway_settings(config_name)
+        def symbolize_keys(hash)
+          return unless hash.is_a?(Hash)
+
+          hash.symbolize_keys!
+          hash.each{|k,v| symbolize_keys(v)}
+        end
+
+        symbolize_keys(YAML.load(File.read(config_name)))
+      end
+
+      # Returns the most applicable identifier of tax area settings available for given COUNTRY and STATE (class)
+      # 
+      # Example:
+      #  taxes = {}
+      #  taxes["ca"] = {"country"=>"CA", "taxes"=>[{"tax"=>{"name"=>"Tax1"}, "rate"=>0.05}], "state"=>"*"}
+      #  taxes[""us_ca""] = {"country"=>"US", "taxes"=>[{"tax"=>{"name"=>"Sample tax"}, "rate"=>0.2}], "state"=>"CA"}
+      #  get_taxes_id(taxes, 'RU', 'MSK') # => StandardError
+      #  get_taxes_id(taxes, 'CA', 'ON') # => "ca"
+      #  get_taxes_id(taxes, 'US', 'CA') # => "us_ca"
+      #  get_taxes_id(taxes, 'US', 'FL') # => StandardError
+      def get_taxes_id(taxes, country, state)
+        return ("%s_%s" % [country, state]).downcase unless (state.empty? || taxes[("%s_%s" % [country, state]).downcase].nil?)
+        return country.downcase unless (country.empty? || taxes[country.downcase].nil?)
+        raise StandardError, 'Tax is unknown for given country and state -  %s, %s' % [country, state]
+      end
+
+      # Returns formatted string for FEATURE hash
+      #
+      # Example 1:
+      # feature['feature']['name'] = 'Message Boards'
+      # feature['quantity'] == nil => 'Message Boards' (when we just want to show that feature is available)
+      # feature['quantity'] == 1, feature['feature']['unit'] == nil => 'Message Boards: 1' (when unit is obvious from feature name)
+      #
+      # Example 2:
+      # feature['feature']['name'] = 'Disk Quota'
+      # feature['quantity'] == 1, feature['feature']['unit'] == 'Gigabyte' => 'Disk Quota: 1 Gigabyte' (when unit is not obvious it has to be specified)
+      # feature['quantity'] == 2, feature['feature']['unit'] == 'Gigabyte' => 'Disk Quota: 2 Gigabytes'
+      # feature['quantity'] == 0, feature['feature']['unit'] == 'Gigabyte' => 'Disk Quota: Unlimited'
+      def format_feature(feature)
+        return "#{feature['feature']['name']}" unless feature['quantity']
+        quantity = feature['quantity']
+        if quantity == 0
+          return "#{feature['feature']['name']}: Unlimited"
+        else
+          return "#{feature['feature']['name']}: #{quantity}" unless feature['feature']['unit']
+          unit_correct_form = (quantity > 1) ? ActiveSupport::Inflector.pluralize(feature['feature']['unit']) : feature['feature']['unit']
+          return "#{feature['feature']['name']}: #{quantity} #{unit_correct_form}"
+        end
+      end
+
+      # Returns human-readable string for standard interval string (PERIODICITY)
+      #
+      # Sample use:
+      #  "1w" => 'each week'
+      #  "0.5 m" => 'twice a month'
+      #  "10 d" => 'each 10 days'
+      #  "3y" => 'each 3 years'
+      #  "0.25 w" => ArgumentError
+      #  "2 x" => ArgumentError
+      def format_periodicity(periodicity)
+        if (periodicity =~ /^(\d+|0\.5)\s*(d|w|m|y)$/i)
+          i_length, i_unit = $1 == '0.5' ? 0.5 : $1.to_i, $2.downcase.to_sym
+        else
+          raise ArgumentError, "Invalid periodicity given: #{periodicity}"
+        end
+
+        text_unit =  case i_unit
+                          when :d then 'day'
+                          when :w then 'week'
+                          when :m then 'month'
+                          when :y then 'year'
+                        end
+
+        return "twice a #{text_unit}" if i_length == 0.5
+        return "each #{text_unit}" if i_length == 1
+        return "each #{i_length} #{ActiveSupport::Inflector.pluralize(text_unit)}"
+      end
+
+    end
+  end
+#end