muck-commerce 0.1.8

data/lib/active_record/acts/muck_coupon.rb

@@ -0,0 +1,137 @@
+module ActiveRecord
+  module Acts #:nodoc:
+    module MuckCoupon #:nodoc:
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+
+        def acts_as_muck_coupon(options = {})
+          validates_presence_of :code, :amount, :percent, :uses
+          validates_uniqueness_of :code
+
+          has_many :orders, :through => :coupons_orders
+          belongs_to :user # coupons can be attached to users for referral codes
+          belongs_to :coupon_type
+
+          validate :validate_discount
+
+          named_scope :by_newest, :order => 'created_at DESC'
+          named_scope :active, :conditions => 'coupons.expires_at > Now() AND coupons.uses <= use_limit'
+
+          include ActiveRecord::Acts::MuckCoupon::InstanceMethods
+          extend ActiveRecord::Acts::MuckCoupon::SingletonMethods
+        end
+      
+      end
+
+      # class methods
+      module SingletonMethods
+        def random_code
+          coupon_length = 14 # will generate a code 15 chars long
+          letters = ['B', 'C', 'D', 'F', 'H', 'J', 'K', 'L', 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'V', 'W', 'X', 'Y', 'Z']
+          numbers = [2, 3, 4, 7, 9]
+          promo_set = letters | numbers # combine arrays
+          begin
+            promo_code = promo_set.sort_by{rand}[0..coupon_length].to_s # randomize array and take the first 15 elements and make them a string
+          end until !self.active_code?(promo_code)
+          promo_code
+        end
+
+        # Checks the database to ensure the specified code is not taken
+        def active_code?(code)
+          Coupon.find_by_code(code)
+        end
+
+        def check_referrals(coupon_codes)
+          # Check to see if the discount code is associated with another user  ie person one invites person two
+          # and so both people get a free month of storage.
+          users = []
+          coupon_codes.each do |code|
+            coupon = Coupon.find_by_code(code)
+            coupon.give_referral_benefit if coupon
+          end
+        end
+
+        # Calculate total discount for a given array of coupon codes.
+        # amount:         amount in cents to calculate discount for
+        # discount_codes: a string coupon code or array of coupon codes
+        def calculate_total_discount(amount, discount_codes)
+          coupon_amount = 0
+          coupon_override = false
+          coupons = []
+          if discount_codes
+            discount_codes = [discount_codes] unless discount_codes.is_a?(Array)
+            discount_codes.each do |discount_code|
+              coupon = Coupon.find_by_code(discount_code)
+              if coupon
+                coupon_amount = coupon.calculate_discount(amount)
+                coupon.redeem
+                coupons << coupon
+              end
+              if amount - coupon_amount == 0
+                coupon_override = true
+              end
+            end
+          end
+          [coupons, coupon_amount, coupon_override]
+        end
+      end
+
+      # All the methods available to a record that has had <tt>acts_as_muck_billing_information</tt> specified.
+      module InstanceMethods
+      
+        def give_referral_benefit
+          raise MuckCommerce::Exceptions::CouponError, "Implement the 'give_referral_benefit' method in coupon.rb."
+        end
+        
+        def validate_discount
+          if self.percent.blank? && self.amount.blank? 
+            errors.add_to_base('Please enter a value for either the coupon amount or percent')
+            false
+          else
+            true
+          end
+        end
+  
+        def calculate_discount(amount)
+    
+          coupon_amount = 0
+    
+          if self.invalid?
+            raise MuckCommerce::Exceptions::CouponError, 'The coupon you entered has expired or is no longer valid'
+          else
+            if self.amount > 0
+              coupon_amount = self.amount
+            elsif self.percent > 0
+              coupon_amount = amount * (0.01 * self.percent)
+            end
+          end
+    
+          coupon_amount = 0 if coupon_amount < 0    
+          coupon_amount
+        end
+  
+        def redeem
+          self.update_attribute(:uses, self.uses + 1)
+        end
+  
+        def invalid?
+          expired? || overused?
+        end
+  
+        def expired?
+          self.expires_at? && self.expires_at < Time.now
+        end
+  
+        def overused?
+          (self.uses >= self.use_limit) && !self.unlimited
+        end
+      end
+    
+    end
+    
+  end
+  
+end

data/lib/active_record/acts/muck_coupon_type.rb

@@ -0,0 +1,34 @@
+module ActiveRecord
+  module Acts #:nodoc:
+    module MuckCouponType #:nodoc:
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+
+        def acts_as_muck_coupon_type(options = {})
+          
+          has_many :coupons
+
+          include ActiveRecord::Acts::MuckCouponType::InstanceMethods
+          extend ActiveRecord::Acts::MuckCouponType::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
+      
+      end
+    
+    end
+    
+  end
+  
+end

data/lib/active_record/acts/muck_order.rb

@@ -0,0 +1,155 @@
+module ActiveRecord
+  module Acts #:nodoc:
+    module MuckOrder #:nodoc:
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      
+      module ClassMethods
+
+        def acts_as_muck_order(options = {})
+          include MuckCommerce::OrderMethods
+          include MuckCommerce::CurrencyMethods
+          include MuckCommerce::DiscountMethods
+          
+          belongs_to :orderable, :polymorphic => true
+
+          has_many :order_transactions, :as => :transactionable, :dependent => :destroy
+          has_many :order_coupons
+          has_many :coupons, :through => :order_coupons
+
+          named_scope :newest, :order => 'created_at DESC'
+          
+          include ActiveRecord::Acts::MuckOrder::InstanceMethods
+          extend ActiveRecord::Acts::MuckOrder::SingletonMethods
+        end
+      
+      end
+      
+      # class methods
+      module SingletonMethods
+      end
+  
+      # All the methods available to a record that has had <tt>acts_as_muck_order</tt> specified.
+      module InstanceMethods
+
+        # Assign a paypal express token to the order
+        def express_token=(token)
+          write_attribute(:express_token, token)
+          if new_record? && !token.blank?
+            details = PAYPAL_EXPRESS_GATEWAY.details_for(token)
+            self.express_payer_id = details.payer_id
+            self.first_name = details.params["first_name"]
+            self.last_name = details.params["last_name"]
+          end
+        end
+
+        # Authorizes a paypal express checkout.
+        # total_in_cents:  The amount to authorize in cents
+        # options:         Options to pass to the paypal gatway.  For example:
+        #                     :subtotal => subtotal_in_cents
+        #                     :handling => handling_in_cents
+        def paypal_express_checkout(total_in_cents, options = {})
+          options = { :ip => self.ip_address,
+                      :token => self.express_token,
+                      :payer_id => self.express_payer_id,
+                      :order_id => order_number}.merge(options)
+          response = PAYPAL_EXPRESS_GATEWAY.authorize(total_in_cents, options)
+          self.amount = total_in_cents
+          self.save!
+
+          authorization = OrderTransaction.parse_response(response, I18n.translate('muck.commerce.paypal_express_authorization'), self.amount)
+          self.transactions << authorization
+          response.success?
+        end
+
+        # This will use the billing information provided along with the amount to run a transaction through
+        # the remote gateway. The resulting transaction will be associated with the order.
+        #
+        # billing_information:  Billing information object that contains valid payment information such as a credit card
+        #                       or ach info. If a remote vault system is enabled such as the Authorize.Net CIM the
+        #                       billing information object need only provide a valid customer_profile_id and
+        #                       customer_payment_profile_id
+        # amount:               Specified in cents so $19.95 should be specified as 1995 this avoids the potential
+        #                       problems with rounding errors.
+        # coupon_code:          A valid coupon code or array of codes that can potentially discount the order. 
+        # options:              Options that can be passed through to the remote gateway.
+        def checkout(billing_information, amount, coupon_codes = [], options = {})
+
+          purchase = nil
+          success = false
+          purchase_made = false
+          amount = amount.to_i # Just in case this comes in as a string
+          
+          options[:order_id] = order_number
+    
+          raise MuckCommerce::Exceptions::PaymentGatewayError, I18n.translate('muck.commerce.order_amount_less_than_zero_error') if amount <= 0
+    
+          transaction do
+
+            coupons, coupon_amount, coupon_override = calculate_discounts(amount, coupon_codes)
+
+            self.amount = amount - coupon_amount
+            self.coupons << coupons
+            
+            if coupon_override
+              # If the coupon drops the price to 0 then there is no need to run a transaction through the gateway
+              self.orderable = billing_information.billable
+              self.discount = coupon_amount
+              success = true
+            else
+
+              if MuckCommerce::Configure.cim_enabled? && !billing_information.has_billing_profile?
+                response = OrderTransaction.cim_create(billing_information)
+                raise MuckCommerce::Exceptions::PaymentGatewayError, I18n.translate('muck.commerce.problem_processing_your_order', :message => response.message) unless response.success?
+              end
+
+              if GlobalConfig.authorize_orders_first
+                if MuckCommerce::Configure.cim_enabled?
+                  purchase = OrderTransaction.cim_authorize(self.amount, billing_information, options)
+                else
+                  purchase = OrderTransaction.authorize(self.amount, billing_information, options)
+                end
+              else
+                if MuckCommerce::Configure.cim_enabled?
+                  purchase = OrderTransaction.cim_purchase(self.amount, billing_information, options)
+                else
+                  purchase = OrderTransaction.purchase(self.amount, billing_information, options)                  
+                end
+              end
+
+              success = purchase.success?
+
+              if success
+                order_transactions.push(purchase)
+                self.orderable = billing_information.billable
+                purchase_made = true
+              else
+                raise MuckCommerce::Exceptions::PaymentGatewayError, I18n.translate('muck.commerce.problem_processing_your_order', :message => purchase.message)
+              end
+            end
+
+            self.save!
+          end
+
+          [success, purchase_made, purchase]
+        end
+
+        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.to_s
+        end
+
+
+      end
+    
+    end
+
+  end
+
+end

data/lib/active_record/acts/muck_order_coupon.rb

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

data/lib/active_record/acts/muck_order_transaction.rb

@@ -0,0 +1,209 @@
+module ActiveRecord
+  module Acts #:nodoc:
+    module MuckOrderTransaction #:nodoc:
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+
+        def acts_as_muck_order_transaction(options = {})
+          belongs_to :transactionable, :polymorphic => true
+          serialize :params
+          cattr_accessor :gateway
+          cattr_accessor :cim_gateway
+          cattr_accessor :paypal_express_gateway
+          
+          named_scope :by_newest, :order => 'order_transactions.created_at DESC'
+          named_scope :by_oldest, :order => 'order_transactions.created_at ASC'
+          
+          include ActiveRecord::Acts::MuckOrderTransaction::InstanceMethods
+          extend ActiveRecord::Acts::MuckOrderTransaction::SingletonMethods
+        end
+      
+      end
+      
+      # class methods
+      module SingletonMethods
+
+        # Make an authorization using the billing_information object provided.  The billing_information
+        # object must have a valid credit card
+        def authorize(amount, billing, options = {})
+          validate_card(billing)
+          process(I18n.translate('muck.commerce.authorization'), amount) do |gw|
+            gw.authorize(amount, billing.credit_card, options)
+          end
+        end
+
+        # Capture funds from the given authorization
+        def capture(amount, authorization, options = {})
+          process(I18n.translate('muck.commerce.capture'), amount) do |gw|
+            gw.capture(amount, authorization, options)
+          end
+        end
+
+        # Make a purchase using the billing_information object provided.  The billing_information
+        # object must have a valid credit card
+        def purchase(amount, billing_information, options = {})
+          validate_card(billing_information)
+          process(I18n.translate('muck.commerce.first_time_purchase'), amount) do |gw|
+            gw.purchase(amount, billing_information.credit_card, options)
+          end
+        end
+
+        # Make an authorization using the CIM.  This assumes that the billing_information object has a 
+        # valid entry in the CIM
+        def cim_authorize(amount, billing_information, options = {})
+          transaction = {
+            :type => :auth_only,
+            :amount => sprintf("%.2f", amount.to_f / 100) # Convert into decimal amount.  HACK/TODO the rest of the library uses cents.  One day this value might need to be cents instead of dollars
+          }
+          transaction[:customer_profile_id] = billing_information.customer_profile_id
+          transaction[:customer_payment_profile_id] = billing_information.customer_payment_profile_id
+          process(I18n.translate('muck.commerce.authorization_cim'), amount, true) do |gw|
+            gw.create_customer_profile_transaction(:transaction => transaction)
+          end
+        end
+
+        # Make a purchase using the CIM.  This assumes that the billing_information object has a 
+        # valid entry in the CIM
+        def cim_purchase(amount, billing_information, options = {})
+          transaction = {
+            :type => :auth_capture,
+            :amount => sprintf("%.2f", amount.to_f / 100) # Convert into decimal amount.  HACK/TODO the rest of the library uses cents.  One day this value might need to be cents instead of dollars
+          }
+          transaction[:customer_profile_id] = billing_information.customer_profile_id
+          transaction[:customer_payment_profile_id] = billing_information.customer_payment_profile_id
+          process(I18n.translate('muck.commerce.purchase_cim'), amount, true) do |gw|
+            gw.create_customer_profile_transaction(:transaction => transaction)
+          end
+        end
+
+        # Creates an entry in the CIM system for the given billing information
+        def cim_create(billing_information)
+          process(I18n.translate('muck.commerce.cim_create'), 0, true) do |gw|
+            response = gw.create_customer_profile(:profile => get_cim_profile(billing_information))
+            if response.success?
+              # these are protected attributes so mass updates are not allowed
+              billing_information.customer_profile_id = response.authorization
+              billing_information.customer_payment_profile_id = response.params["customer_payment_profile_id_list"]["numeric_string"]
+              billing_information.save!
+            end
+            response
+          end
+        end
+
+        # Updates information in the CIM system
+        def cim_update(billing_information, validate = true)
+          profile = get_cim_profile(billing_information, validate)
+          profile[:customer_profile_id] = billing_information.customer_profile_id
+          process(I18n.translate('muck.commerce.cim_update_user'), 0, true) do |gw|
+            gw.update_customer_profile(:profile => profile)
+          end
+        end
+
+        # Creates or updates billing information in the CIM based on whether or not it already exists.
+        def cim_create_update(billing_information, validate = true)
+          if billing_information.has_billing_profile?
+            self.cim_update(billing_information, validate)
+          else
+            self.cim_create(billing_information)
+          end
+        end
+
+        # Remove billing information from the CIM system.
+        def cim_delete(billing_information)
+          process(I18n.translate('muck.commerce.cim_delete_user'), 0, true) do |gw|
+            gw.delete_customer_profile(:customer_profile_id => billing_information.customer_profile_id) 
+          end
+        end
+    
+        # validates an existing profile
+        def cim_validate_user(billing_information)
+          process(I18n.translate('muck.commerce.cim_validate_profile'), 0, true) do |gw|
+            gw.validate_customer_payment_profile(
+            :customer_profile_id => billing_information.customer_profile_id,
+            :customer_payment_profile_id => billing_information.customer_payment_profile_id,
+            :validation_mode => :live)
+          end
+        end
+    
+        # Transfer money to an email account using paypal
+        def send_money_via_paypal(amount, email, options = {})
+          process(I18n.translate('muck.commerce.send_money_via_paypal'), amount) do |gw|
+            gw.transfer(amount, email, options)
+          end      
+        end
+        
+        private
+
+          # Get a profile object compatible with the CIM system.
+          def get_cim_profile (billing_information, validate = true)
+            validate_card(billing_information) if validate
+            billable = billing_information.billable
+            payment = { :credit_card => billing_information.credit_card_for_cim }
+            address = { :first_name => billing_information.first_name,
+                        :last_name => billing_information.last_name }
+            address[:company] = billing_information.company unless billing_information.company.blank?
+            address[:address] = "#{billing_information.address1} #{billing_information.address2}" unless billing_information.address1.blank?
+            address[:city] = billing_information.city unless billing_information.city.blank?
+            address[:state] = billing_information.state.name unless billing_information.state.blank?
+            address[:country] = billing_information.country.name unless billing_information.country.blank?
+            address[:zip] = billing_information.postal_code unless billing_information.postal_code.blank?
+            profile = {
+              :merchant_customer_id => billable.id,
+              :description => "#{billable.type}",
+              :email => billable.email,
+              :payment_profiles => {
+                :customer_type => 'individual',
+                :bill_to => address,
+                :payment => payment
+              }
+            }
+            profile
+          end
+    
+          def validate_card(billing)
+            raise MuckCommerce::Exceptions::PaymentGatewayError, I18n.translate('muck.commerce.invalid_credit_card_information') if !billing.credit_card.valid?
+          end
+    
+          def process(action, amount = nil, cim_transaction = false)
+            result = OrderTransaction.new
+            result.amount = amount
+            result.action = action
+            begin
+              if cim_transaction
+                response = yield cim_gateway
+              else
+                response = yield gateway
+              end
+              result.success   = response.success?
+              result.reference = response.authorization
+              result.message   = response.message
+              result.params    = response.params
+              result.test      = response.test?        
+            rescue ActiveMerchant::ActiveMerchantError => e
+              result.success   = false
+              result.reference = nil
+              result.message   = e.message
+              result.params    = {}
+              result.test      = gateway.test?
+            end
+      
+            result
+          end
+      end
+      
+      
+      # All the methods available to a record that has had <tt>acts_as_muck_order_transaction</tt> specified.
+      module InstanceMethods
+        
+        def direct_message
+          self.params['direct_response']['message']
+        end
+        
+      end
+      
+    end  
+  end
+end