billing_logic 0.0.3

data/lib/billing_logic/billing_cycle.rb

@@ -0,0 +1,77 @@
+module BillingLogic
+  class BillingCycle
+    include Comparable
+    attr_accessor :period, :frequency, :anniversary
+    TIME_UNITS = { :day => 1, :week => 7, :month => 365/12.0, :semimonth=> 365/24, :year => 365 }
+
+    # Creates a new BillingCycle instance
+    #
+    # @param opts [Hash] holds :period, :frequency, and :anniversary
+    # @return [BillingCycle] a billing cycle with .period, .frequency and .anniversary
+    def initialize(opts = {})
+      self.period = opts[:period]
+      self.frequency = opts[:frequency] || 1
+      self.anniversary = opts[:anniversary]
+    end
+
+    # Compares self against another BillingCycle instance by #periodicity
+    #
+    # @param other [BillingCycle] another BillingCycle instance
+    # @return [-1, 0, 1] integer determined by which BillingCycle is longer
+    def <=>(other)
+      self.periodicity <=> other.periodicity
+    end
+
+    def periodicity
+      time_unit_measure * frequency
+    end
+
+    def days_in_billing_cycle_including(date)
+      (closest_anniversary_date_including(date) - anniversary).abs
+    end
+
+    # Date on which the next payment is due and scheduled to be paid
+    # anniversary will always equal date
+    def next_payment_date
+      closest_future_anniversary_date_including(anniversary)
+    end
+    
+    # Used for prorationing in the single payment strategy
+    # Not currently in use
+    def closest_anniversary_date_including(date) 
+      date_in_past = date < anniversary
+      advance_date_by_period(anniversary, date_in_past)
+    end
+
+    def closest_future_anniversary_date_including(date)
+      return anniversary if anniversary > date
+      return advance_date_by_period(anniversary.dup) if anniversary == date
+      next_anniversary = anniversary.dup
+      while(date > next_anniversary) 
+        next_anniversary = advance_date_by_period(next_anniversary)
+      end
+      next_anniversary
+    end
+
+    def advance_date_by_period(date, revert = false)
+      operators =   {:month => revert ? :<< : :>>, 
+                     :day   => revert ? :-  : :+ }
+      case self.period
+      when :year
+        date.send(operators[:month], (self.frequency * 12))
+      when :month
+        date.send(operators[:month], self.frequency)
+      when :week
+        date.send(operators[:month], (self.frequency * 7))
+      when :day
+        date.send(operators[:month], self.frequency)
+      end
+    end
+
+    private
+    def time_unit_measure
+      TIME_UNITS[self.period]
+    end
+
+  end
+end

data/lib/billing_logic/command_builders/command_builders.rb

@@ -0,0 +1,179 @@
+module BillingLogic
+  module CommandBuilders
+    SINGLE_PRODUCT_REGEX = '(\w+) @ \$([\d\.]+)(\/mo|\/yr)?'
+    DATE_REGEX  = '(\d{1,2}\/\d{1,2}\/\d{2,4})'
+    MONEY_REGEX = '\$([\d\.]+)'
+
+    module BuilderHelpers
+      def self.money(money)
+        "%01.2f" % Float(money)
+      end
+    end
+
+    class ProductList
+      # ProductList.parse returns a dumb array
+      # You can't add behavior (I tried adding #price)
+      def self.parse(string, options = {})
+        if (products = (string =~ /\(([^\(\)]*)\)/) ? $1 : nil)
+          products.split(/ & /).map do |product_string|
+            ProductStub.parse(product_string, options)
+          end
+        else
+          []
+        end
+      end
+    end
+
+    class ProductStub
+      attr_accessor :name, :price, :identifier, :billing_cycle, :payments, :initial_payment
+      def self.parse(string, options = {})
+        string =~ /#{BillingLogic::CommandBuilders::SINGLE_PRODUCT_REGEX}/
+        billing_cycle = $3 ? ::BillingLogic::BillingCycle.new(:frequency => 1, :period => $3.include?('mo') ? :month : :year) : nil
+        product = (options[:product_class] || self).new
+        product.name = $1
+        product.price = Float($2)
+        product.identifier = "#{$1} @ $#{$2}#{$3}"
+        product.billing_cycle = billing_cycle
+        product.initial_payment = options[:initial_payment] || 0
+        product
+      end
+
+    end
+
+    class ActionObject
+      DATE_FORMAT = '%m/%d/%y'
+
+      attr_accessor :action, :products, :profile_id, :initial_payment, :disable, :refund, :starts_on, :price
+
+      def initialize(opts = {})
+        @action           = opts[:action]
+        @profile_id       = opts[:profile_id]
+        @products         = opts[:products]
+        @disable          = opts[:disable]
+        @refund           = opts[:refund]
+        @initial_payment  = opts[:initial_payment]
+        @starts_on        = opts[:starts_on]
+        @price            = opts[:price]
+      end
+
+      def to_s
+        if [:cancel, :remove, :add, :add_bundle].include?(action)
+          send("#{action.to_s}_action_string")
+        end
+      end
+
+      def cancel_action_string
+        "cancel #{'and disable ' if disable}[#{profile_id}] #{"with refund $#{BuilderHelpers.money(refund)} " if refund}now"
+      end
+
+      def remove_action_string
+        "remove (#{products.map { |product| product.identifier }.join(" & ")}) from [#{profile_id}] #{"with refund $#{BuilderHelpers.money(refund)} " if refund}now"
+      end
+
+      def add_action_string
+        products.map do |product|
+          initial_payment_string = total_initial_payment.zero? ? '' : " with initial payment set to $#{BuilderHelpers.money(total_initial_payment)}"
+          "add (#{product.identifier}) on #{starts_on.strftime(DATE_FORMAT)}#{initial_payment_string}"
+        end.to_s
+      end
+
+      def add_bundle_action_string
+        product_ids = products.map { |product| product.identifier }.join(' & ')
+        price ||= products.inject(0){ |k, product| k += product.price; k }
+        initial_payment_string = total_initial_payment.zero? ? '' : " with initial payment set to $#{BuilderHelpers.money(total_initial_payment)}"
+        "add (#{product_ids}) @ $#{BuilderHelpers.money(price)}#{periodicity_abbrev(products.first.billing_cycle.period)} on #{starts_on.strftime(DATE_FORMAT)}#{initial_payment_string}"
+      end
+
+      def self.from_string(string, options = {:product_class => ProductStub})
+        opts = {}
+        opts[:action]     = case string
+                            when /^add \(.*\) @/
+                              :add_bundle
+                            when /^(cancel|remove|add)/
+                              $1.to_sym
+                            end
+        opts[:disable]    = !!(string =~ /and disable/)
+        opts[:starts_on]  = (string =~ /on #{BillingLogic::CommandBuilders::DATE_REGEX}/) ? Date.strptime($1, DATE_FORMAT) : (string =~ /now$/) ? Time.now : nil
+        opts[:products] = ProductList.parse(string, options)
+
+        opts[:profile_id] = case opts[:action]
+                            when :cancel, :remove
+                              string =~ /\[(.*)\]/ ? $1 : nil
+                            end
+        opts[:refund]     = (string =~ /with refund #{BillingLogic::CommandBuilders::MONEY_REGEX}/) ? Float($1) : nil
+        opts[:initial_payment] = (string =~ /with initial payment set to #{BillingLogic::CommandBuilders::MONEY_REGEX}/) ? Float($1) : nil
+        opts[:price]      = (string =~ /add \(.*\) @ #{BillingLogic::CommandBuilders::MONEY_REGEX}/) ? Float($1) : nil
+
+        self.new(opts)
+      end
+
+      def total_initial_payment
+        @initial_payment ||= products.map { |product| product.initial_payment || 0 }.reduce(0) { |a, e| a + e }
+      end
+
+      protected
+      def periodicity_abbrev(period)
+        case period
+        when :year; '/yr'
+        when :month;'/mo'
+        when :week; '/wk'
+        when :day;  '/day'
+        else
+          period
+        end
+      end
+    end
+
+    class BasicBuilder
+      class << self
+        def create_recurring_payment_commands(products, opts = {:paid_until_date => Date.current})
+          raise Exception.new('Implement me')
+        end
+
+        # override this with Time.zone if used with rails
+        def time
+          Time
+        end
+
+        def cancel_recurring_payment_commands(profile, opts = {})
+          ActionObject.new(opts.merge(:action     => :cancel,
+                                      :profile_id => profile.identifier,
+                                      :products   => profile.products,
+                                      :when       => time.now))
+        end
+
+        def remove_product_from_payment_profile(profile_id, products, opts)
+          ActionObject.new(opts.merge(:action     => :remove,
+                                      :products   => products,
+                                      :profile_id => profile_id,
+                                      :when       => time.now))
+        end
+      end
+    end
+
+    class WordBuilder < BasicBuilder
+      class << self
+        def create_recurring_payment_commands(products, opts = {:paid_until_date => Date.current})
+          ActionObject.new(opts.merge(:action     => :add,
+                                      :products   => products,
+                                      :starts_on  => opts[:paid_until_date],
+                                      :when       => time.now))
+        end
+      end
+    end
+
+    class AggregateWordBuilder < BasicBuilder
+      class << self
+        include CommandBuilders::BuilderHelpers
+        def create_recurring_payment_commands(products, opts = {:paid_until_date => Date.current, :price => nil, :frequency => 1, :period => nil})
+          ActionObject.new(opts.merge(:action     => :add_bundle,
+                                      :products   => products,
+                                      :starts_on  => opts[:paid_until_date],
+                                      :when       => time.now))
+        end
+      end
+    end
+  end
+
+end
+

data/lib/billing_logic/current_state.rb

@@ -0,0 +1,18 @@
+require 'billing_logic/current_state_mixin'
+module BillingLogic
+
+  # Holds the array of current PaymentProfiles
+  class CurrentState
+
+    include BillingLogic::CurrentStateMixin
+    
+    # Initializes a CurrentState object holding an array of current PaymentProfiles
+    #
+    # @return [CurrentState] the CurrentState object holding an array of current PaymentProfiles
+    def initialize(profiles)
+      @profiles = profiles
+    end
+
+  end
+
+end

data/lib/billing_logic/current_state_mixin.rb

@@ -0,0 +1,32 @@
+module BillingLogic
+  module CurrentStateMixin
+    def self.included(clazz)
+      clazz.send(:attr_accessor, :profiles)
+      clazz.send(:include, Enumerable)
+    end
+
+    # Iterates through profiles, yielding each one-by-one to the block for processing
+    def each(&block)
+      profiles.each(&block)
+    end
+
+    # Returns array with only BillingEngine::Client::Products belonging to the CurrentState's current
+    # (i.e., currently paid-up) PaymentProfiles
+    #
+    # @return [Array] array of BillingEngine::Client::Products belonging to CurrentState's "current"
+    #   PaymentProfiles (i.e., where paid_until_date >= Date.current )
+    def current_products
+      map { |profile| profile.current_products }.flatten
+    end
+
+    # Returns array with only BillingEngine::Client::Products belonging to the CurrentState's active
+    # (i.e., enabled & active/pending) PaymentProfiles
+    #
+    # @return [Array] array of BillingEngine::Client::Products belonging to CurrentState's
+    #   "active" PaymentProfiles (i.e., where an 'active' PaymentProfile has #enabled => 1/true
+    #   and #profile_status either 'active' or 'pending')
+    def active_products
+      map { |profile| profile.active_products }.flatten
+    end
+  end
+end

data/lib/billing_logic/payment_command_builder.rb

@@ -0,0 +1,54 @@
+module BillingLogic
+
+  # Converts an array of BillingEngine::Client::Products and a next_payment_date into (string) commands
+  # for creating recurring_payments. Also converts a list of PaymentProfile#ids into
+  # commands for canceling their recurring_payments.
+  class PaymentCommandBuilder
+
+    # Creates a PaymentCommandBuilder from an array of BillingEngine::Client::Products
+    #
+    # @param products [Array<BillingEngine::Client::Product>]
+    def initialize(products)
+      @products = products
+    end
+
+    # Groups BillingEngine::Client::Products into a hash with keys of BillingEngine::Client::Product#billing_cycle and values of the products
+    def group_products_by_billing_cycle
+      @products.inject({}) do |a, e|
+        a[e.billing_cycle] ||= []
+        a[e.billing_cycle] << e
+        a
+      end
+    end
+
+    class << self
+
+      
+      # @return [String] the (string) command for creating recurring payments for
+      #   the passed-in array of BillingEngine::Client::Products with the passed-in next_payment_date
+      def create_recurring_payment_commands(products, next_payment_date = Date.current)
+        self.new(products).group_products_by_billing_cycle.map do |k, prods|
+          {
+            :action => 'create_recurring_payment',
+            :products => prods,
+            :price => prods.inject(0) { |a, e| a + e.price; a },
+            :next_payment_date => next_payment_date,
+            :billing_cycle => k
+          }
+        end
+      end
+
+      # @return [String] the (string) command for canceling recurring payments for
+      #   the passed-in array of PaymentProfile#ids
+      def cancel_recurring_payment_commands(*profile_ids)
+        profile_ids.map do |profile_id| 
+          {
+            :action => :cancel_recurring_payment,
+            :payment_profile_id => profile_id
+          }
+        end
+      end
+    end
+
+  end
+end

data/lib/billing_logic/proration_calculator.rb

@@ -0,0 +1,25 @@
+module BillingLogic
+  class ProrationCalculator
+    attr_accessor :billing_cycle, :price, :date
+    def initialize(opts = {})
+      self.billing_cycle = opts[:billing_cycle]
+      self.price = opts[:price]
+      self.date  = opts[:date]
+    end
+
+    def prorate_from(date = self.date)
+      return price if date == self.billing_cycle.anniversary
+      average_daily_price_for_billing_cycle(date) * distance_from_date_in_days(date)
+    end
+    alias :prorate :prorate_from
+
+    def distance_from_date_in_days(date = self.date)
+      (date - self.billing_cycle.anniversary).abs
+    end
+
+    def average_daily_price_for_billing_cycle(date = self.date)
+      (self.price / (self.billing_cycle.days_in_billing_cycle_including(date)))
+    end
+
+  end
+end