muck-commerce 0.1.8

data/lib/active_record/acts/muck_subscription.rb

@@ -0,0 +1,289 @@
+module ActiveRecord
+  module Acts #:nodoc:
+    module MuckSubscription #:nodoc:
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      
+      module ClassMethods
+
+        def acts_as_muck_subscription(options = {})
+          
+          include AASM
+          include MuckCommerce::OrderMethods
+
+          belongs_to :user
+          belongs_to :subscription_plan
+
+          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
+          named_scope :expiring_trials, lambda { |*args| {:include => [:user], 
+                                                          :conditions => ["subscriptions.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 ]} }
+
+          # subscriptions due today (or another day as specified)
+          named_scope :due_today, lambda { |*args| {:include => [:user],
+                                              :conditions => ["(subscriptions.state = 'active' || subscriptions.state = 'trial') AND subscriptions.next_renewal_at BETWEEN ? AND ?",
+                                                                              (args.first || Time.now).beginning_of_day,
+                                                                              (args.first || Time.now).end_of_day ]} }
+
+          # all past due subscriptions
+          named_scope :past_due, lambda { |*args| {:include => [:user],
+                                                   :conditions => ["(subscriptions.state = 'active' || subscriptions.state = 'trial' || subscriptions.state = 'suspended') AND subscriptions.next_renewal_at < ?", 
+                                                                        Time.now.end_of_day ]} }
+
+          named_scope :newest, :order => 'created_at DESC'
+
+          named_scope :default, :conditions => '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
+          
+          include ActiveRecord::Acts::MuckSubscription::InstanceMethods
+          extend ActiveRecord::Acts::MuckSubscription::SingletonMethods
+        end
+      
+      end
+      
+      
+      # class methods
+      module SingletonMethods
+      
+        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, 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 = '')
+          raise MuckCommerce::Exceptions::SubscriptionError, 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(current_user, params) 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!
+            sub
+          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(current_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
+
+        private
+        def timestamp_attribute(attribute_name, time = Time.now)
+          self.update_attribute(attribute_name, time)
+        end
+       
+      end
+      
+      
+      module InstanceMethods
+        
+        def suspend_subscription
+          timestamp_attribute(:suspended_at)
+          self.user.remove_from_role('subscriber')
+          MessageMailer.deliver_cc_declined(self.user)
+        end
+
+        def activate_subscription
+          self.update_attributes(:activated_at => Time.now, :suspended_at => nil, :cancelled_at => nil)
+          user.roles << Role.find_by_name('subscriber') unless user.subscriber?
+        end
+
+        def cancel_subscription
+          timestamp_attribute(:cancelled_at)
+          self.user.remove_from_role('subscriber')
+        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 > GlobalConfig.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
+
+end

data/lib/active_record/acts/muck_subscription_plan.rb

@@ -0,0 +1,34 @@
+module ActiveRecord
+  module Acts #:nodoc:
+    module MuckSubscriptionPlan #:nodoc:
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      
+      module ClassMethods
+
+        def acts_as_muck_subscription_plan(options = {})
+          
+          validates_uniqueness_of :name
+          validates_presence_of :name, :amount, :renewal_period, :trial_period 
+          named_scope :by_name, :order => 'name ASC'
+          
+          include ActiveRecord::Acts::MuckSubscriptionPlan::InstanceMethods
+          extend ActiveRecord::Acts::MuckSubscriptionPlan::SingletonMethods
+        end
+      
+      end
+      
+      # class methods
+      module SingletonMethods
+      end
+  
+      # All the methods available to a record that has had <tt>acts_as_muck_subscription_plan</tt> specified.
+      module InstanceMethods
+      end
+    
+    end
+
+  end
+
+end

data/lib/muck_commerce/cart_methods.rb

@@ -0,0 +1,54 @@
+module MuckCommerce
+  module CartMethods
+
+    protected 
+
+    def recover_cart
+      @cart = get_cart(@user)
+    
+      # TODO this is a security preference.  In theory one user could get into another user's cart
+      # if @cart && @cart.user
+      #   allowed_access?(:owner => current_user, :object_user_id => @cart.user_id, :permit_roles => ['administrator']) 
+      # end
+    end
+  
+    def get_cart(user)
+      if user && user.cart
+        convert_existing_to_user_cart(user)
+        cookies[:cart_token] = user.cart.token
+        return user.cart 
+      end
+    
+      user = nil if user == false
+    
+      if cookies[:cart_token]
+        cart = Cart.find_by_token(cookies[:cart_token])
+      else
+        cart = Cart.create(:cartable => user)
+        cookies[:cart_token] = cart.token
+      end
+      cart
+    end
+  
+    def convert_existing_to_user_cart(user)
+      cart_too = Cart.find_by_token(cookies[:cart_token]) if cookies[:cart_token]
+      if cart_too
+        cart_too.items.each do |item|
+          item.cart = user.cart
+          item.save
+        end
+      end
+    end
+  
+    def permission_denied
+      respond_to do |format|
+        format.html do
+          flash[:notice] = 'Please login to view your cart'
+          redirect_to login_path
+        end
+      end
+    end
+  
+  end
+
+end

data/lib/muck_commerce/configure.rb

@@ -0,0 +1,94 @@
+module MuckCommerce
+  class Configure
+    
+    def self.enable_live_test_gateway(gateway = nil, cim_gateway = nil, login = nil, password = nil, signature = nil)
+      gateway(true, gateway, cim_gateway, login, password, signature)
+      GlobalConfig.credit_card_types = [[ "Visa", "visa" ], [ "MasterCard", "master" ], [ "Discover", "discover" ], [ "American Express", "american_express" ]]
+    end
+
+    def self.disable_live_test_gateway
+      gateway
+    end
+
+    def self.cim_enabled?
+      @cim_enabled
+    end
+
+    # Configures the gateway for payment transactions.
+    #
+    # Notes:
+    # For most uses the default options are fine and the gateway can be configured by simply calling:
+    # MuckCommerce::Configure.gateway as shown below.
+    #
+    # To configure the gateway for your application add the following to environment.rb
+    #    config.after_initialize do
+    #      MuckCommerce::Configure.gateway
+    #    end
+    #
+    # The development environment will also require the addition of the same configuration.  
+    # This is required so that the gateway is properly setup for each request.
+    # Without it the gateway will be nil after the first request.
+    # Add the following to development.rb
+    #   config.to_prepare do
+    #     MuckCommerce::Configure.gateway
+    #   end
+    #
+    # Parameters:
+    #   enable_live_test_gateway:  Normally tests are run against the local bogus gateway.  However, tests 
+    #                              can use the live test gateway by setting this value to true.  The tests
+    #                              found in test/rails_root/remote make use of this option.
+    #   gateway:                   Override the gateway specified in global_config.yml.
+    #   cim_gateway:               Override the cim_gateway specified in global_config.yml.
+    #   login:                     Override the login specified in global_config.yml.
+    #   password:                  Override the password specified in global_config.yml.
+    #   signature:                 Override the signature specified in global_config.yml.
+    #   production_test:           If set to true then the system will use the test gateway even in production.  
+    #                              Useful if you want to test the production site before going live
+    #             
+    def self.gateway(enable_live_test_gateway = false, gateway = nil, cim_gateway = nil, login = nil, password = nil, signature = nil, production_test = false)
+
+      production_test ||= GlobalConfig.commerce_run_production_as_test
+      if !production_test && Rails.env.production?
+        ActiveMerchant::Billing::Base.mode = :production
+      else
+        ActiveMerchant::Billing::Base.mode = :test 
+      end
+
+      if !enable_live_test_gateway && Rails.env.test?
+        OrderTransaction.gateway = ActiveMerchant::Billing::BogusGateway.new
+        OrderTransaction.cim_gateway = ActiveMerchant::Billing::BogusGateway.new
+        OrderTransaction.paypal_express_gateway = ActiveMerchant::Billing::BogusGateway.new
+        GlobalConfig.credit_card_types = [[ "Visa", "bogus" ], [ "MasterCard", "bogus" ], [ "Discover", "bogus" ], [ "American Express", "bogus" ]]
+        @cim_enabled = false
+      else
+        # These settings connect your system with the paypal express gateway.  This will enable checkout via paypal.
+        if GlobalConfig.enable_paypal_express
+          paypal_options = {
+            :login => login || GlobalConfig.paypal_login,
+            :password => password || GlobalConfig.paypal_password,
+            :signature => signature || GlobalConfig.paypal_signature
+          }
+          OrderTransaction.paypal_express_gateway = ActiveMerchant::Billing::PaypalExpressGateway.new(paypal_options)
+        end
+
+        # These are the options (usually only a login and password) required to connect with your payment gateway.
+        gateway_options = {
+          :login => login || GlobalConfig.gateway_login,
+          :password => password || GlobalConfig.gateway_password,
+        }
+        # Paypal requires a signature.  If you are using paypal as your processing gateway be sure to include this signature.
+        gateway_options.merge!(:signature => signature || GlobalConfig.gateway_signature) if signature || GlobalConfig.gateway_signature
+
+        # This is the gateway that will be used to process ecommerce related transactions
+        OrderTransaction.gateway = ActiveMerchant::Billing::Base.gateway(gateway || GlobalConfig.gateway.to_sym).new(gateway_options)
+
+        # CIM (Authorize.net) or Vault (Braintree) systems are used to securely store sensitive customer information at the gateway
+        OrderTransaction.cim_gateway = ActiveMerchant::Billing::Base.gateway(cim_gateway || GlobalConfig.cim_gateway.to_sym).new(gateway_options) if cim_gateway || GlobalConfig.cim_gateway
+
+        @cim_enabled = !OrderTransaction.cim_gateway.blank?
+      end
+
+    end
+    
+  end
+end

data/lib/muck_commerce/currency_methods.rb

@@ -0,0 +1,36 @@
+module MuckCommerce
+  module CurrencyMethods
+
+    # Assumes a field named amount
+    def amount_dollars= val
+      self.amount = dollars_to_cents(val)
+    end
+
+    # Assumes a field named amount
+    def amount_dollars
+      cents_to_dollars(self.amount)
+    end
+    
+    # Assumes a field named amount
+    # Get the order amount as a formatted currency instead of as cents. 
+    def amount_price
+      format_currency(self.amount)
+    end
+
+    protected
+
+      def format_currency(val)
+        format("%.2f", cents_to_dollars(val))
+      end
+
+      def cents_to_dollars(val)
+        val * 0.01
+      end
+
+      def dollars_to_cents(val)
+        val * 100
+      end
+
+  end
+
+end

data/lib/muck_commerce/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 GlobalConfig.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/exceptions.rb

@@ -0,0 +1,8 @@
+module MuckCommerce
+  module Exceptions
+    class InvalidValue < StandardError; end
+    class PaymentGatewayError < StandardError; end
+    class CouponError < StandardError; end
+    class SubscriptionError < StandardError; end
+  end
+end

data/lib/muck_commerce/initialize_routes.rb

@@ -0,0 +1,8 @@
+class ActionController::Routing::RouteSet
+  def load_routes_with_muck_commerce!
+    muck_commerce_routes = File.join(File.dirname(__FILE__), *%w[.. .. config muck_commerce_routes.rb])
+    add_configuration_file(muck_commerce_routes) unless configuration_files.include? muck_commerce_routes
+    load_routes_without_muck_commerce!
+  end
+  alias_method_chain :load_routes!, :muck_commerce
+end

data/lib/muck_commerce/muck_custom_form_builder.rb

@@ -0,0 +1,22 @@
+module MuckCommerceCustomFormBuilder
+
+  # creates a select control with payment options.
+  def payment_method_select(method, options = {}, html_options = {})
+    self.select(method, GlobalConfig.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, GlobalConfig.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, GlobalConfig.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, GlobalConfig.achtypes, options.merge(:prompt => "Select ACH Type", :wrapper_id => 'achtypes-container'), html_options.merge(:id => 'achtypes'))
+  end
+  
+end
+
+MuckCustomFormBuilder.send :include, MuckCommerceCustomFormBuilder

data/lib/muck_commerce/order_methods.rb

@@ -0,0 +1,19 @@
+module MuckCommerce
+  module OrderMethods
+  
+    def order_number
+      return self.number if !self.number.nil?
+      record = true
+      while record
+        random = Array.new(10){rand(10)}.join
+        record = Order.find(:first, :conditions => ["number = ?", random])
+      end
+      self.number = random
+    end
+  
+    def dollar_amount
+      self.amount * 0.01
+    end
+  
+  end
+end

data/lib/muck_commerce/paypal_methods.rb

@@ -0,0 +1,28 @@
+# This module is meant to be mixed into a controller that needs to support paypal express transactions
+module MuckCommerce
+  module PaypalMethods
+
+    def express
+        response = OrderTransaction.paypal_express_gateway.setup_authorization(@cart.total,
+          :ip                => request.remote_ip,
+          :return_url        => build_paypal_express_return_url,
+          :cancel_return_url => build_paypal_express_cancel_url
+        )
+        redirect_to OrderTransaction.paypal_express_gateway.redirect_url_for(response.token)
+      end
+
+    protected
+      def build_paypal_express_return_url
+        new_order_url
+      end
+
+      def build_paypal_express_cancel_url
+        cart_url(@cart)
+      end
+
+      def paypal_express?
+        !params[:token].blank?
+      end
+
+  end
+ end

data/lib/muck_commerce/tasks.rb

@@ -0,0 +1,41 @@
+require 'rake'
+require 'rake/tasklib'
+require 'fileutils'
+
+module MuckCommerce
+  class Tasks < ::Rake::TaskLib
+    def initialize
+      define
+    end
+
+    private
+    def define
+
+      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
+
+    end
+  end
+end
+MuckCommerce::Tasks.new