muck-commerce 0.2.8 → 3.0.1

data/lib/muck-commerce/models/subscription.rb

@@ -0,0 +1,265 @@
+# include MuckCommerce::Models::MuckSubscription
+module MuckCommerce
+  module Models
+    module MuckSubscription
+      extend ActiveSupport::Concern
+      
+      included do
+
+        include ::AASM
+        include ::MuckCommerce::OrderMethods
+
+        belongs_to :user
+        belongs_to :subscription_plan
+        
+        has_many :subscription_records
+        has_many :order_coupons
+        has_many :coupons, :through => :subscription_coupons
+        has_many :order_transactions, :as => :transactionable, :dependent => :destroy
+
+        delegate :trial_period, :to => :subscription_plan
+
+        validates_presence_of :amount, :user
+
+        # look for subscriptions that expire one week out
+        scope :expiring_trials, lambda { |*args| where(["subscriptions.aasm_state = 'trial' AND subscriptions.next_renewal_at BETWEEN ? AND ?",
+                                                                              (args.first || 7.days.from_now).beginning_of_day, 
+                                                                              (args.first || 7.days.from_now).end_of_day ]).includes(:user) }
+
+        # subscriptions due today (or another day as specified)
+        scope :due_today, lambda { |*args| where(["(subscriptions.aasm_state = 'active' || subscriptions.aasm_state = 'trial') AND subscriptions.next_renewal_at BETWEEN ? AND ?",
+                                                                            (args.first || Time.now).beginning_of_day,
+                                                                            (args.first || Time.now).end_of_day ]).includes(:user) }
+
+        # all past due subscriptions
+        scope :past_due, lambda { |*args| where(["(subscriptions.aasm_state = 'active' || subscriptions.aasm_state = 'trial' || subscriptions.aasm_state = 'suspended') AND subscriptions.next_renewal_at < ?", 
+                                                                      Time.now.end_of_day ]).includes(:user) }
+
+        scope :by_newest, order("created_at DESC")
+
+        scope :default, where('subscriptions.default = 1')
+
+        aasm_initial_state :trial
+
+        aasm_state :trial
+        aasm_state :active, :enter => :activate_subscription
+        aasm_state :cancelled, :enter => :cancel_subscription
+        aasm_state :suspended, :enter => :suspend_subscription
+        
+        aasm_event :cancel do
+          transitions :from => :trial, :to => :cancelled
+          transitions :from => :active, :to => :cancelled
+        end
+
+        aasm_event :activate do
+          transitions :from => :trial, :to => :active
+          transitions :from => :suspended, :to => :active
+          transitions :from => :cancelled, :to => :active
+        end
+
+        aasm_event :suspend do
+          transitions :from => :trial, :to => :suspended
+          transitions :from => :active, :to => :suspended
+        end
+      
+      end
+      
+      module ClassMethods
+      
+        def authorize_subscription(user, options = {})
+          amount = 100 # run a $1 authorization on their credit card
+          User.transaction do
+            begin
+              authorization = OrderTransaction.authorize(amount, user.billing_information, options)
+              raise MuckCommerce::Exceptions::PaymentGatewayError, I18n.t('muck.commerce.billing_information_update_error_friendly', :error => authorization.message) if !authorization.success? 
+              store_information_response = OrderTransaction.cim_create_update(user.billing_information)
+            rescue => ex
+              #puts pp user.billing_information.credit_card.errors
+              #puts ex
+              success = false
+              raise ex
+            end
+            [success, authorization, store_information_response]
+          end      
+        end
+
+        def subscribe(user, subscription_plan_id, discount_code = '', authorize_options = {})
+          raise MuckCommerce::Exceptions::SubscriptionError, I18n.t('muck.commerce.already_subscribed') if already_subscribed?(user, subscription_plan_id)
+          subscription_plan = SubscriptionPlan.find(subscription_plan_id)
+          coupon, coupon_amount, coupon_override = Coupon.calculate_total_discount(subscription_plan.amount, discount_code)
+          success, authorization, store_information_response = Subscription.authorize_subscription(user, authorize_options) if !coupon_override
+
+          sub = nil
+          if success
+            sub = Subscription.new
+            sub.number = sub.order_number
+            sub.user = user
+            sub.coupon = coupon if coupon
+            sub.subscription_plan = subscription_plan
+            sub.next_renewal_at = DateTime.now.advance(:days => subscription_plan.trial_period.days)
+            sub.renewal_period = subscription_plan.renewal_period
+            if coupon_override
+              sub.amount = 0
+            else
+              sub.amount = subscription_plan.amount - coupon_amount
+            end
+            sub.save!
+          end
+
+          [sub, authorization, store_information_response]
+        end
+        
+        # Setup a custom subscription.  This is done in the event that every subscription for every user is different.
+        # These subscriptions are not associated with a subscription plan because each one is custom.
+        # It is assumed that the first bill will not go out for the amount of time specified by renewal_period.
+        # This is done so that the first bill can be handled by order.checkout so that there is an order associated with 
+        # the user.
+        # user:              User to setup subscription for.
+        # amount:            Amount of the subscription. Specified in cents.
+        # subscription_values: Optional values for the subscription.
+        # renewal_period:    Amount of time between charges.  If no value is provided 1 month will be assumed.
+        # discount_codes:    An array containing potential discount codes or coupons.  These will be checked against the 
+        #                    coupons table and associated with the subscription if they are valid.
+        # run_authorization: Determines whether or not to run an authorization on the user's billing information to see 
+        #                    if it is valid.
+        def subscribe_custom(user, amount, subscription_values = {}, renewal_period = nil, discount_codes = [], run_authorization = false)
+          coupons, coupon_amount, coupon_override = Coupon.calculate_total_discount(amount, discount_codes)
+          if !coupon_override && run_authorization
+            success, authorization, store_information_response = Subscription.authorize_subscription(user, params)
+          else
+            success = true
+          end
+          
+          sub = nil
+          if success
+            sub = Subscription.new(subscription_values)
+            sub.number = sub.order_number
+            sub.user = user
+            sub.coupons << coupons unless coupons.empty?
+            
+            if renewal_period
+              sub.next_renewal_at = DateTime.now.advance(:days => renewal_period)
+              sub.renewal_period = renewal_period
+            else
+              sub.next_renewal_at = DateTime.now.advance(:months => 1)
+            end
+            
+            if coupon_override
+              sub.amount = 0
+            else
+              sub.amount = amount - coupon_amount
+            end
+            sub.save!
+            sub
+          end
+
+          [sub, authorization, store_information_response]
+        end
+        
+        # Determines if a user is already subscribed to a given plan
+        def already_subscribed?(user, subscription_plan_id)
+          user.subscriptions.any? { |subscription| subscription.subscription_plan_id == subscription_plan_id }
+        end
+
+        def process_past_due_subscriptions
+          results = past_due.map {|subscription| subscription.charge}
+          results_log_message("PAST DUE SUBSCRIPTIONS:", results)
+        end
+
+        private
+        def results_log_message(message, results)
+          failure_count = results.select {|result| result == false}.length
+          succeeded_count = results.select {|result| result == true}.length
+          "#{message}\tProcessed: #{results.size}\tFailed: #{failure_count}\tSucceeded: #{succeeded_count}"
+        end
+       
+      end
+
+      
+      def suspend_subscription
+        self.update_attribute(:suspended_at, Time.now)
+        CommerceMailer.cc_declined(self.user).deliver
+      end
+
+      def activate_subscription
+        self.update_attributes(:activated_at => Time.now, :suspended_at => nil, :cancelled_at => nil)
+      end
+
+      def cancel_subscription
+        self.update_attribute(:cancelled_at, Time.now)
+      end
+
+      def past_due?
+        self.next_renewal_at < DateTime.now.beginning_of_day
+      end
+
+      def reset_billing_date
+        if self.renewal_period
+          update_attributes(:next_renewal_at => self.next_renewal_at.advance(:days => self.renewal_period), :failed_billing_attempts => 0)
+        else
+          update_attributes(:next_renewal_at => DateTime.now.advance(:months => 1), :failed_billing_attempts => 0)
+        end
+      end
+
+      def reactivate_if_needed!
+        return true if self.active? && !past_due?
+        if OrderTransaction.cim_validate_user(self.user.billing_information).success?
+          self.update_attributes(:failed_billing_attempts => 0)
+          self.activate!
+          true
+        else
+          false
+        end
+      end
+
+      def charge
+        return false if self.cancelled? || self.suspended?
+
+        return true if self.user.non_billable?
+
+        if self.user.billing_information.blank?
+          success = false
+        elsif self.amount == 0
+          success = true
+        else
+          @purchase = OrderTransaction.cim_purchase(self.amount_in_dollars, self.user.billing_information)
+          success = @purchase.success?
+          self.order_transactions.push(@purchase) if @purchase
+        end
+
+        if success
+          self.reset_billing_date
+          self.activate! if self.trial?
+          true
+        else
+          self.update_attribute(:failed_billing_attempts, self.failed_billing_attempts + 1)
+          if self.failed_billing_attempts > MuckCommerce.configuration.max_billing_attempt_failures
+            self.suspend!
+          end
+          false
+        end
+      end
+
+      def enroll_user_in_program_courses
+        self.subscription_plan.programs.each do |program|
+          program.enroll_user(self.user)
+        end
+      end
+
+      def coupon_code
+        coupon.nil? ? "" : coupon.code
+      end
+
+      def needs_payment_info?
+        self.user.billing_information.blank?
+      end
+      
+      def amount_price
+        self.amount/100.0
+      end
+      
+    end
+  
+  end
+
+end

data/lib/muck-commerce/models/subscription_plan.rb

@@ -0,0 +1,17 @@
+# include MuckCommerce::Models::MuckSubscriptionPlan
+module MuckCommerce
+  module Models
+    module MuckSubscriptionPlan
+      extend ActiveSupport::Concern
+      
+      included do
+        validates_uniqueness_of :name
+        validates_presence_of :name, :amount, :renewal_period, :trial_period 
+        scope :by_name, order('name ASC')
+      end
+    
+    end
+
+  end
+
+end

data/lib/muck-commerce/models/subscription_record.rb

@@ -0,0 +1,16 @@
+# include MuckCommerce::Models::MuckSubscriptionRecord
+module MuckCommerce
+  module Models
+    module MuckSubscriptionRecord
+      extend ActiveSupport::Concern
+
+      # Subscription records are used to record extra information each time a
+      # subscription is billed.      
+      included do
+        validates_presence_of :amount
+        belongs_to :subscription
+      end
+    
+    end
+  end
+end

data/lib/muck-commerce/models/user.rb

@@ -0,0 +1,69 @@
+# include MuckCommerce::Models::MuckUser
+module MuckCommerce
+  module Models
+    module MuckUser
+      extend ActiveSupport::Concern
+      
+      included do
+        
+        # Ties a user into the muck commerce system and adds order, carts, etc.
+        # Access cart using:
+        #   @user.cart
+        # Access default billing information:
+        #   @user.billing_information 
+        # Each user can have a referral code which can be accessed using:
+        #   @user.referral_code
+        has_one :cart, :as => :cartable, :dependent => :destroy
+        has_many :billing_informations, :as => :billable, :dependent => :destroy
+        has_many :order_transactions, :as => :transactionable, :dependent => :destroy
+        has_many :orders, :as => :orderable
+        has_many :subscriptions, :dependent => :destroy
+        has_one :referral_coupon_code, :class_name => 'Coupon'
+      end
+
+
+      # This is the description that will be passed to the CIM system
+      def cim_description
+        self.display_name
+      end
+      
+      def subscription
+        @default_subscription ||= self.subscriptions.default.first
+      end
+
+      # Get the user's default billing information
+      def billing_information
+        bi = self.billing_informations.default.first
+        # In case this is a new user the above call will return nil. Try to get billing information object from array:
+        bi ||= self.billing_informations.first if self.billing_informations.length == 1
+        bi
+      end
+
+      # Setup or update billing information for the user
+      def create_update_billing_information!(billing_information)
+        if self.billing_information
+          @default_billing_information = self.billing_information
+          @default_billing_information.update_attributes!(billing_information)
+        else
+          @default_billing_information = BillingInformation.create!(billing_information.merge(:default => true))
+          self.billing_informations << @default_billing_information
+        end
+
+        @default_billing_information.update_remote_storage
+
+        @default_billing_information
+      end
+
+      # Build but do not save billing information for the user
+      def build_billing_information(billing_information)
+        BillingInformation.new(billing_information.merge(:default => true, :user_id => self.id))  
+      end
+      
+      def referral_code
+        self.referral_coupon_code ||= Coupon.create(:code => Coupon.random_code, :unlimited => true, :coupon_type => CouponType.user_referral)
+      end
+      
+    end
+    
+  end
+end

data/lib/muck-commerce/share/discount_methods.rb

@@ -0,0 +1,17 @@
+module MuckCommerce
+  module DiscountMethods
+
+    def calculate_discounts(amount, coupon_codes)
+      coupons = []
+      coupon_amount = 0
+      coupon_override = false
+      if MuckCommerce.configuration.enable_coupons && coupon_codes
+        coupons, coupon_amount, coupon_override = Coupon.calculate_total_discount(amount, coupon_codes)
+      end
+      [coupons, coupon_amount, coupon_override]
+    end
+    
+  end
+
+end
+

data/lib/muck-commerce/share/muck_custom_form_builder.rb

@@ -0,0 +1,20 @@
+module MuckCommerceCustomFormBuilder
+
+  # creates a select control with payment options.
+  def payment_method_select(method, options = {}, html_options = {})
+    self.select(method, MuckCommerce.configuration.payment_methods, options.merge(:wrapper_id => 'payment-options-container'), html_options.merge(:id => 'payment-options'))
+  end
+
+  def credit_card_type_select(method, options = {}, html_options = {})
+    self.select(method, MuckCommerce.configuration.credit_card_types, options.merge(:prompt => "Select a credit card", :wrapper_id => 'credit-card-types-container'), html_options.merge(:id => 'credit-card-types'))
+  end
+  
+  def achholder_select(method, options = {}, html_options = {})
+    self.select(method, MuckCommerce.configuration.achholder_types, options.merge(:prompt => "Select ACH Holder", :wrapper_id => 'achholder-types-container'), html_options.merge(:id => 'achholder-types'))
+  end
+  
+  def achtype_select(method, options = {}, html_options = {})
+    self.select(method, MuckCommerce.configuration.achtypes, options.merge(:prompt => "Select ACH Type", :wrapper_id => 'achtypes-container'), html_options.merge(:id => 'achtypes'))
+  end
+  
+end

data/lib/tasks/muck_commerce.rake

@@ -0,0 +1,24 @@
+require 'fileutils'
+
+namespace :muck do
+  namespace :sync do
+
+    # namespace :db do
+    # 
+    #   desc "Populates the database with default values"
+    #   task :populate => :environment do
+    #     
+    #   end
+    # 
+    # end
+
+    desc "Sync files from muck commerce."
+    task :commerce do
+      path = File.join(File.dirname(__FILE__), *%w[.. ..])
+      system "rsync -ruv #{path}/db ."
+      #system "rsync -ruv #{path}/public ."
+    end
+    
+  end
+
+end

data/lib/test/muck_commerce_factories.rb

@@ -55,8 +55,8 @@ Factory.define :ach_billing, :class => BillingInformation do |f|
   f.achname { Factory.next(:name) }
   f.achrouting '3333'
   f.achnumber '22222'
-  f.achholder GlobalConfig.achholder_types[0][0]
-  f.achtype GlobalConfig.achtypes[0][0]
+  f.achholder MuckCommerce.configuration.achholder_types[0][0]
+  f.achtype MuckCommerce.configuration.achtypes[0][0]
   f.billable   {|a| a.association(:user)}
 end