muck-commerce 0.1.8

data/db/migrate/20091230220327_create_muck_commerce.rb

@@ -0,0 +1,144 @@
+class CreateMuckCommerce < ActiveRecord::Migration
+  def self.up
+
+    create_table :billing_informations, :force => true do |t|
+      t.integer  "billable_id"
+      t.string   "billable_type"
+      t.string   "first_name",              :limit => 128,  :default => "", :null => false
+      t.string   "last_name",               :limit => 128,  :default => "", :null => false
+      t.string   "address1",                :limit => 512,  :default => "", :null => false
+      t.string   "address2",                :limit => 512
+      t.string   "city",                    :limit => 128,  :default => "", :null => false
+      t.integer  "state_id"
+      t.integer  "country_id"
+      t.string   "postal_code",                             :default => "", :null => false
+      t.string   "telephone",                               :default => "", :null => false
+      t.string   "payment_method",                          :default => 'CC'
+      t.string   "credit_card_type"
+      t.string   "credit_card_last_digits", :limit => 4
+      t.datetime "credit_card_expiration"
+      t.string   "achname",                 :limit => 1024
+      t.string   "achrouting",              :limit => 1024
+      t.string   "achnumber",               :limit => 1024
+      t.string   "achholder",               :limit => 1024
+      t.string   "achtype",                 :limit => 64
+      t.string   "vault_id",                :limit => 512
+      t.string   "customer_profile_id",         :limit => 512
+      t.string   "customer_payment_profile_id", :limit => 512
+      t.boolean  "default",                                 :default => false
+      t.timestamps
+    end
+    add_index "billing_informations", ["billable_id", "billable_type"]
+
+
+    create_table :carts, :force => true do |t|
+      t.integer  "cartable_id"
+      t.string   "cartable_type"
+      t.string   "token"
+      t.timestamps
+    end
+    add_index "carts", ["cartable_id", "cartable_type"]
+
+
+    create_table :cart_coupons, :force => true do |t|
+      t.integer  "cart_id"
+      t.integer  "coupon_id"
+      t.timestamps
+    end
+    add_index "cart_coupons", ["cart_id", "coupon_id"]
+
+    create_table :coupons, :force => true do |t|
+      t.string   "code"
+      t.integer  "amount",     :default => 0,     :null => false
+      t.integer  "percent",    :default => 0,     :null => false
+      t.integer  "uses",       :default => 0,     :null => false
+      t.boolean  "unlimited",  :default => false, :null => false
+      t.datetime "expires_at"
+      t.integer  "use_limit",  :default => 1,     :null => false
+      t.timestamps
+    end
+    add_index "coupons", ["code"]
+
+
+    create_table :order_transactions, :force => true do |t|
+      t.integer  "amount"
+      t.boolean  "success"
+      t.string   "reference"
+      t.string   "message"
+      t.string   "action"
+      t.text     "params"
+      t.boolean  "test"
+      t.integer  "transactionable_id"
+      t.string   "transactionable_type"
+      t.integer  "response_code"
+      t.timestamps
+    end
+    add_index "order_transactions", ["transactionable_id"]
+
+
+    create_table :orders, :force => true do |t|
+      t.integer  "orderable_id"
+      t.string   "orderable_type"
+      t.integer  "amount"
+      t.integer  "discount"
+      t.string   "number"
+      t.string   "first_name"
+      t.string   "last_name"
+      t.string   "ip_address"
+      t.string   "express_token"
+      t.string   "express_payer_id"
+      t.string   "order_type"
+      t.timestamps
+    end
+    add_index "orders", ["orderable_id", "orderable_type"]
+
+
+    create_table :order_coupons, :force => true do |t|
+      t.integer  "order_id"
+      t.integer  "coupon_id"
+      t.timestamps
+    end
+    add_index "order_coupons", ["order_id", "coupon_id"]
+    
+    
+    create_table :subscription_plans, :force => true do |t|
+      t.string   "name"
+      t.string   "sku"
+      t.integer  "amount"
+      t.integer  "renewal_period"
+      t.integer  "trial_period"
+      t.timestamps
+    end
+    add_index "subscription_plans", ["name"]
+
+
+    create_table :subscriptions, :force => true do |t|
+      t.integer  "user_id"
+      t.integer  "amount"
+      t.datetime "next_renewal_at"
+      t.string   "aasm_state",              :default => "trial"
+      t.integer  "subscription_plan_id"
+      t.integer  "renewal_period"
+      t.string   "number"
+      t.integer  "failed_billing_attempts", :default => 0,       :null => false
+      t.datetime "cancelled_at"
+      t.datetime "suspended_at"
+      t.datetime "activated_at"
+      t.boolean  "default",                 :default => false
+      t.timestamps
+    end
+    add_index "subscriptions", ["user_id"]
+    
+  end
+
+  def self.down
+    drop_table :subscriptions
+    drop_table :subscription_plans
+    drop_table :orders
+    drop_table :order_transactions
+    drop_table :coupons
+    drop_table :carts
+    drop_table :billing_informations
+  end
+
+end

data/db/migrate/20100119221052_add_name_to_billing.rb

@@ -0,0 +1,9 @@
+class AddNameToBilling < ActiveRecord::Migration
+  def self.up
+    add_column :billing_informations, :name, :string, :limit => 256
+  end
+
+  def self.down
+    remove_column :billing_informations, :name
+  end
+end

data/db/migrate/20100120060511_add_company_to_billing.rb

@@ -0,0 +1,9 @@
+class AddCompanyToBilling < ActiveRecord::Migration
+  def self.up
+    add_column :billing_informations, :company, :string, :limit => 256
+  end
+
+  def self.down
+    remove_column :billing_informations, :company
+  end
+end

data/db/migrate/20100228060913_create_subscription_coupons.rb

@@ -0,0 +1,14 @@
+class CreateSubscriptionCoupons < ActiveRecord::Migration
+  def self.up
+    create_table :subscription_coupons, :force => true do |t|
+      t.integer  "subscription_id"
+      t.integer  "coupon_id"
+      t.timestamps
+    end
+    add_index "subscription_coupons", ["subscription_id", "coupon_id"]
+  end
+
+  def self.down
+    drop_table :subscription_coupons
+  end
+end

data/db/migrate/20100309183304_add_coupon_subscrption_uses.rb

@@ -0,0 +1,11 @@
+class AddCouponSubscrptionUses < ActiveRecord::Migration
+  def self.up
+    add_column :coupons, :use_for_times, :integer
+    add_column :coupons, :use_for_months, :integer
+  end
+
+  def self.down
+    remove_column :coupons, :use_for_times
+    remove_column :coupons, :use_for_months
+  end
+end

data/db/migrate/20100310180031_create_coupon_types.rb

@@ -0,0 +1,15 @@
+class CreateCouponTypes < ActiveRecord::Migration
+  def self.up
+    add_column :coupons, :user_id, :integer
+    add_column :coupons, :coupon_type_id, :integer
+    create_table :coupon_types, :force => true do |t|
+      t.string   :name
+    end
+  end
+
+  def self.down
+    drop_table :coupon_types
+    remove_column :coupons, :user_id
+    remove_column :coupons, :coupon_type_id
+  end
+end

data/lib/action_controller/muck_billing_application.rb

@@ -0,0 +1,77 @@
+module ActionController
+  module MuckBillingApplication
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+
+      def acts_as_muck_billing_application(options = {})
+        include ActionController::MuckBillingApplication::InstanceMethods
+      end
+
+    end
+
+    module InstanceMethods
+
+      protected
+
+        def after_billing_create(billing_success, vault_success)
+          if billing_success && vault_success
+            yield
+          elsif billing_success && !vault_success
+            #flash[:notice] = I18n.translate('muck.commerce.vault_config_error')
+            render :template => "billing_informations/edit"
+          else
+            render :template => "billing_informations/new"
+          end
+        end
+        
+        def after_user_billing_create(user_success)
+          billing_success, vault_success = setup_billing if user_success
+          if user_success && billing_success && vault_success
+            yield
+          elsif !user_success
+            render :template => "users/new"
+          else
+            # need to remove flash messages since the user setup isn't totally complete.
+            flash.clear
+            after_billing_create(billing_success, vault_success)
+          end
+        end
+
+        def setup_billing
+          if @user.billing_information
+            @billing_information = @user.billing_information
+            @billing_information.attributes = params[:billing_information]
+          else
+            @billing_information = BillingInformation.new(params[:billing_information])
+            @billing_information.billable = @user
+          end
+          vault_success = true
+          if success = @billing_information.credit_card.valid?
+            success = @billing_information.save
+            if success
+              if GlobalConfig.cim_gateway
+                begin
+                  response = OrderTransaction.cim_create(@billing_information)
+                  @user.order_transactions.push(response)
+                rescue MuckCommerce::Exceptions::PaymentGatewayError => ex
+                  flash[:error] = I18n.translate('muck.commerce.billing_information_problem', :message => ex.to_s)
+                end
+                vault_success = response.success?
+                if !vault_success
+                  flash[:error] = I18n.translate('muck.commerce.billing_information_problem', :message => response.message)
+                end
+              end
+            end
+          else
+            flash[:error] = I18n.translate('muck.commerce.invalid_credit_card_information')
+          end
+          [success, vault_success]
+        end
+
+    end
+  end
+end

data/lib/active_record/acts/muck_billing_information.rb

@@ -0,0 +1,231 @@
+module ActiveRecord
+  module Acts #:nodoc:
+    module MuckBillingInformation #:nodoc:
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+
+        def acts_as_muck_billing_information(options = {})
+          include ActiveMerchant::Billing::CreditCardMethods
+          
+          belongs_to :billable, :polymorphic => true
+          belongs_to :state
+          belongs_to :country
+
+          # Requirements vary so require fields in the model
+          # validates_presence_of :name
+          # validates_presence_of :postal_code
+          
+          validates_presence_of :credit_card_number
+          validates_presence_of :credit_card_expiration
+
+          validates_presence_of :achname, :if => :is_ach?
+          validates_presence_of :achrouting, :if => :is_ach?
+          validates_presence_of :achnumber, :if => :is_ach?
+
+          validates_presence_of :verification_value, :if => :require_cvv_value?
+
+          attr_accessible :first_name, :last_name, :name,
+                          :address1, :address2, :city, :state_id, :country_id, :postal_code, :telephone,
+                          :credit_card_number, :credit_card_expiration, :credit_card_type, :verification_value,
+                          :default
+          attr_accessor :verification_value
+
+          named_scope :by_newest, :order => 'billing_informations.created_at DESC'
+          named_scope :default, :conditions => 'billing_informations.default = 1'
+          
+          include ActiveRecord::Acts::MuckBillingInformation::InstanceMethods
+          extend ActiveRecord::Acts::MuckBillingInformation::SingletonMethods
+        end
+      
+      end
+      
+      # class methods
+      module SingletonMethods
+
+      end
+      
+      # All the methods available to a record that has had <tt>acts_as_muck_billing_information</tt> specified.
+      module InstanceMethods
+
+        # Uses local checks to see if the billing information is valid
+        def billing_valid?
+          has_errors = false
+          begin
+            unless valid_expiry_year?(credit_card_expiration && credit_card_expiration.year) && valid_month?(credit_card_expiration && credit_card_expiration.month)
+              has_errors = true
+              errors.add(:credit_card_expiration, I18n.translate('muck.commerce.credit_card_expiration_invalid', :month => credit_card_expiration.month, :year => credit_card_expiration.year))
+            end
+            if !GlobalConfig.credit_card_types.map {|disp, value| value.downcase}.include?(self.credit_card_type)
+              self.guess_card_type
+              # guess the card type and try again
+              if !GlobalConfig.credit_card_types.map {|disp, value| value.downcase}.include?(self.credit_card_type)
+                has_errors = true
+                errors.add(:credit_card_type, I18n.translate('muck.commerce.credit_card_type_invalid', :type => self.credit_card_type))
+              end
+            end
+            if !self.class.valid_number?(credit_card_number)
+              has_errors = true
+              errors.add(:credit_card_number, I18n.translate('muck.commerce.credit_card_number_invalid', :number => self.credit_card.display_number))
+            end
+            
+            cc = self.credit_card
+            if !cc.valid?
+              has_errors = true
+              errors.add_to_base(I18n.translate('muck.commerce.credit_card_information_invalid', :errors => cc.errors.full_messages.to_sentence, 
+                                                                                                 :month => cc.month, 
+                                                                                                 :year => cc.year, 
+                                                                                                 :type => cc.type, 
+                                                                                                 :number => cc.display_number))
+            end                                                                                      
+          rescue => ex
+            has_errors = true
+            errors.add_to_base(I18n.translate('muck.commerce.credit_card_information_validation_exception', :error => ex))
+          end
+          
+          !has_errors
+
+        end
+  
+        def credit_card_type=(val)
+          write_attribute(:credit_card_type, val.downcase) unless val.nil?
+        end
+  
+        # don't store the credit card number
+        def credit_card_number=(val)
+          @credit_card_number_value = val
+          write_attribute(:credit_card_last_digits, self.class.last_digits(@credit_card_number_value)) # only store the last 4 digits for customer reference    
+        end
+  
+        def credit_card_number
+          @credit_card_number_value || "XXXX-XXXX-XXXX-#{read_attribute(:credit_card_last_digits)}"
+        end
+
+        def credit_card_number_available?
+          return false if self.credit_card_number.blank?
+          self.credit_card_number.to_s.length > 4
+        end
+  
+        def credit_card_for_cim
+          if self.credit_card_number_available?
+            self.credit_card
+          else
+            # if we don't have a credit card we don't want to try to update the cim with just 4 digits
+            # passing this mask will tell the cim not to update the card at all
+            OpenStruct.new(:number => "XXXX#{self.credit_card_number}", 
+                           :year => self.credit_card_expiration.year, 
+                           :month => self.credit_card_expiration.month)
+          end
+        end
+
+        # Updates billing information in remote storage such as Authorize.net CIM or Braintree vault
+        def update_remote_storage
+          response = nil
+          message = ''
+          if MuckCommerce::Configure.cim_enabled?
+            # Update CIM if billing information has changed
+            response = OrderTransaction.cim_create_update(@billing_information, @billing_information.credit_card_number_available?)
+            if response.success?
+              message = translate('muck.commerce.billing_information_updated')
+            else
+              message = translate('muck.commerce.billing_information_update_error', :error => response.message)
+            end
+          end
+          [response, message]
+        end
+
+        def secure_display
+          "xxxx-xxxx-xxxx-#{self.credit_card_last_digits}"
+        end
+  
+        def has_cvv?
+          !self.verification_value.blank?
+        end
+
+        def require_cvv_value?
+          GlobalConfig.require_cvv_value
+        end
+
+        def credit_card?
+          'CC' == self.payment_method
+        end
+
+        def is_ach?
+          'ACH' == self.payment_method
+        end
+
+        def guess_card_type
+          self.credit_card_type = ActiveMerchant::Billing::CreditCard.type?(self.credit_card_number)
+        end
+
+        def is_authorized?
+          amount = 100 # run a $1 authorization on their credit card
+          authorization = OrderTransaction.authorize(amount, self)
+          raise MuckCommerce::Exceptions::PaymentGatewayError, I18n.translate('muck.commerce.payment_information_problem', :message => authorization.message) if !authorization.success?
+          authorization.success?
+        end
+        
+        def get_first_name
+          if !self.first_name.blank?
+            self.first_name
+          else
+            self.parse_name(self.name)[0]
+          end
+        end
+        
+        def get_last_name
+          if !self.last_name.blank?
+            self.last_name
+          else
+            self.parse_name(self.name)[1]
+          end
+        end
+        
+        def parse_name(name)
+          return '' if name.blank?
+          names = name.split(' ')
+          return '' if names.length <= 0
+          return [names[0], names[0]] if names.length == 1
+          [names[0], names.slice(1, names.length).join(' ')]
+        end
+        
+        def credit_card
+          card_options = {
+            :first_name => self.get_first_name,
+            :last_name => self.get_last_name,
+            :number => self.credit_card_number,
+            :type => self.credit_card_type }
+          card_options[:month] = self.credit_card_expiration.month if self.credit_card_expiration
+          card_options[:year] = self.credit_card_expiration.year if self.credit_card_expiration
+          has_cvv? ? build_card_with_cvv(card_options) : build_card_without_cvv(card_options)
+        end
+   
+        def has_billing_profile? 
+          !self.customer_profile_id.blank? || !self.customer_payment_profile_id.blank?
+        end
+   
+        private
+
+          def build_card_with_cvv(options)
+            build_card_with_options(options.merge!({:verification_value => self.verification_value}))
+          end
+
+          def build_card_without_cvv(options)
+            card = build_card_with_options(options)
+            card.require_verification_value = false
+            card
+          end
+
+          def build_card_with_options(options)
+            ActiveMerchant::Billing::CreditCard.new(options)
+          end
+          
+      end
+      
+    end
+
+  end
+
+end

data/lib/active_record/acts/muck_cart.rb

@@ -0,0 +1,56 @@
+module ActiveRecord
+  module Acts #:nodoc:
+    module MuckCart #:nodoc:
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+
+        def acts_as_muck_cart(options = {})
+          include MuckCommerce::CurrencyMethods
+          include MuckCommerce::DiscountMethods
+          
+          belongs_to :cartable, :polymorphic => true
+
+          has_many :cart_coupons
+          has_many :coupons, :through => :cart_coupons
+
+          include ActiveRecord::Acts::MuckCart::InstanceMethods
+          extend ActiveRecord::Acts::MuckCart::SingletonMethods
+        end
+
+      end
+
+      # class methods
+      module SingletonMethods
+
+      end
+
+      # All the methods available to a record that has had <tt>acts_as_muck_cart</tt> specified.
+      module InstanceMethods
+        
+        def empty?
+          self.items.empty?
+        end
+
+        def before_create
+          generate_token
+        end
+
+        def generate_token
+          self.token = Digest::SHA1.hexdigest("--#{Time.now.to_s}--#{self.id}--")
+        end
+
+        # Override this method in your cart
+        def items
+          []
+        end
+
+      end
+      
+    end
+
+  end
+
+end

data/lib/active_record/acts/muck_cart_coupon.rb

@@ -0,0 +1,35 @@
+
+module ActiveRecord
+  module Acts #:nodoc:
+    module MuckCartCoupon #:nodoc:
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+
+        def acts_as_muck_cart_coupon(options = {})
+
+          belongs_to :coupon
+          belongs_to :cart
+
+          include ActiveRecord::Acts::MuckCartCoupon::InstanceMethods
+          extend ActiveRecord::Acts::MuckCartCoupon::SingletonMethods
+        end
+
+      end
+
+      # class methods
+      module SingletonMethods
+
+      end
+
+      module InstanceMethods
+
+      end
+
+    end
+
+  end
+
+end

data/lib/active_record/acts/muck_commerce_user.rb

@@ -0,0 +1,64 @@
+module ActiveRecord
+  module Acts #:nodoc:
+    module MuckCommerceUser # :nodoc:
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+  
+      module ClassMethods
+        
+        # +acts_as_muck_commerce_user+ ties a user into the muck commerce system and adds order, carts, etc.
+        def acts_as_muck_commerce_user
+          
+          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
+          
+          include ActiveRecord::Acts::MuckCommerceUser::InstanceMethods
+          extend ActiveRecord::Acts::MuckCommerceUser::SingletonMethods
+        end
+      end
+
+      # class methods
+      module SingletonMethods
+      end
+      
+      module InstanceMethods
+
+        def subscription
+          @default_subscription ||= self.subscriptions.default.first
+        end
+
+        # Get the user's default billing information
+        def billing_information
+          self.billing_informations.default.first
+        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
+
+      end
+      
+    end
+  end
+end