glysellin 0.4.1

data/app/models/glysellin/order.rb

@@ -0,0 +1,243 @@
+require 'state_machine'
+
+module Glysellin
+  class Order < ActiveRecord::Base
+    include ProductsList
+    include Orderer
+
+    self.table_name = 'glysellin_orders'
+
+    attr_accessor :discount_code
+
+    state_machine initial: :ready do
+
+      event :paid do
+        transition any => :paid
+      end
+
+      event :shipped do
+        transition paid: :shipped
+      end
+
+      after_transition on: :choose_shipping_method, do: :set_shipping_price
+      after_transition on: :paid, do: :set_payment
+    end
+
+    # Relations
+    #
+    # Order products are used to map order to cloned and simplified products
+    #   so the Order propererties can't be affected by product updates
+    has_many :products, class_name: 'Glysellin::OrderItem',
+      foreign_key: 'order_id', dependent: :destroy
+
+    # The actual buyer
+    belongs_to :customer, class_name: "::#{ Glysellin.user_class_name }",
+      foreign_key: 'customer_id', :autosave => true
+
+    # Payment tries
+    has_many :payments, inverse_of: :order, dependent: :destroy
+
+    belongs_to :shipping_method, inverse_of: :orders
+
+    has_many :order_adjustments, inverse_of: :order, dependent: :destroy
+
+    # We want to be able to see fields_for addresses
+    accepts_nested_attributes_for :products
+    # accepts_nested_attributes_for :customer
+    accepts_nested_attributes_for :payments
+    accepts_nested_attributes_for :order_adjustments
+
+    attr_accessible :payments, :products, :products_ids,
+      :customer, :customer_id, :ref, :user, :payments,
+      :payments_attributes, :products_attributes, :paid_on,
+      :state, :payment_method_id, :billing_address, :shipping_address,
+      :shipping_method_id, :discount_code, :order_adjustments_attributes
+
+    validates_presence_of :customer, :billing_address, :shipping_address,
+      :products
+
+    before_validation :process_adjustments
+    after_save :ensure_ref
+    after_create :ensure_customer_addresses
+    before_save :set_paid_if_paid_by_check
+    before_save :notify_shipped
+
+    scope :from_customer, lambda { |customer_id| where(customer_id: customer_id) }
+
+    def quantified_items
+      products.map { |product| [product, product.quantity] }
+    end
+
+    # Ensures there is always an order reference
+    #
+    def ensure_ref
+      update_attribute(:ref, self.generate_ref) unless self.ref
+    end
+
+    # Ensures that the customer hash a billing and, if needed shipping, address.
+    #
+    def ensure_customer_addresses
+      unless customer.billing_address
+        customer.create_billing_address(billing_address.clone_attributes)
+
+        unless billing_address.same_as?(shipping_address)
+          customer.create_shipping_address(shipping_address.clone_attributes)
+        end
+      end
+    end
+
+    # If admin sets payment date by hand and order was paid by check,
+    # fire :paid event
+    #
+    def set_paid_if_paid_by_check
+      paid! if (paid_on_changed? and ready? and paid_by_check?)
+    end
+
+    def paid_by_check?
+      payment and payment.by_check?
+    end
+
+    def set_shipping_price
+      build_adjustment_from shipping_method if shipping_method
+    end
+
+    # Callback invoked after event :paid
+    def set_payment
+      self.payment.new_status Payment::PAYMENT_STATUS_PAID
+      update_attribute(:paid_on, payment.last_payment_action_on)
+    end
+
+    # Callback invoked after event :shipped
+    def notify_shipped
+      if state_changed? && shipped?
+        OrderCustomerMailer.send_order_shipped_email(self).deliver
+      end
+    end
+
+    def init_payment!
+      self.payments.build unless payment
+    end
+
+    # Define model to use it's ref when asked for parameterized
+    #   representation of itself
+    #
+    # @return [String] the order ref
+    def to_param
+      ref
+    end
+
+    # Automatic ref generation for an order that can be overriden
+    #   within the config initializer, and only executes if there's no
+    #   existing ref inside for this order
+    #
+    # @return [String] the generated or existing ref
+    def generate_ref
+      if ref
+        ref
+      else
+        if Glysellin.order_reference_generator
+          Glysellin.order_reference_generator.call(self)
+        else
+          "#{Time.now.strftime('%Y%m%d%H%M')}-#{id}"
+        end
+      end
+    end
+
+    # Customer's e-mail directly accessible from the order
+    #
+    # @return [String] the wanted e-mail string
+    def email
+      customer && customer.email
+    end
+
+    ########################################
+    #
+    #               Products
+    #
+    ########################################
+
+    def products=(attributes)
+      products = attributes.reduce([]) do |list, product|
+        item = OrderItem.build_from_product(product[:id], product[:quantity])
+        item ? (list << item) : list
+      end
+
+      super(products)
+    end
+
+    ########################################
+    #
+    #               Adjustments
+    #
+    ########################################
+
+    def build_adjustment_from item
+      # Handle replacing duplicate adjustments on the same order
+      existing_adjustments = order_adjustments.where(
+        adjustment_type: item.class.to_s
+      )
+      # Destroy exisiting ones
+      existing_adjustments.each(&:destroy) if existing_adjustments.length > 0
+      # Build new adjustment from existing discount code
+      order_adjustments.build(item.to_adjustment(self))
+    end
+
+    def process_adjustments
+      build_adjustment_from(shipping_method) if shipping_method
+
+      if discount_code
+        code = Glysellin::DiscountCode.from_code(discount_code)
+        build_adjustment_from(code) if code
+      end
+    end
+
+    ########################################
+    #
+    #               Payment
+    #
+    ########################################
+
+    # Gives the last payment found for that order
+    #
+    # @return [Payment, nil] the found Payment item or nil
+    def payment
+      payments.last
+    end
+
+    # Returns the last payment method used if there has already been
+    #   a payment try
+    #
+    # @return [PaymentType, nil] the PaymentMethod or nil
+    def payment_method
+      payment.type rescue nil
+    end
+
+    def payment_method_id=(type_id)
+      payment = self.payments.build :status => Payment::PAYMENT_STATUS_PENDING
+      payment.type = PaymentMethod.find(type_id)
+    end
+
+
+    ########################################
+    #
+    #              Adresses
+    #
+    ########################################
+
+    # Set customer from a Hash of attributes
+    #
+    def customer=(attributes)
+      unless (self.customer_id = attributes[:id])
+        user = self.build_customer(attributes)
+
+        if Glysellin.allow_anonymous_orders &&
+          !(user.password || user.password_confirmation)
+
+          password = (rand*(10**20)).to_i.to_s(36)
+          user.password = password
+          user.password_confirmation = password
+        end
+      end
+    end
+  end
+end

data/app/models/glysellin/order_adjustment.rb

@@ -0,0 +1,19 @@
+module Glysellin
+  class OrderAdjustment < ActiveRecord::Base
+    self.table_name = 'glysellin_order_adjustments'
+
+    attr_accessible :adjustment_id, :adjustment_type, :name, :order_id, :value,
+      :adjustment, :order
+
+    belongs_to :order
+    belongs_to :adjustment, polymorphic: true
+
+    def type
+      adjustment_type.demodulize.underscore.dasherize
+    end
+
+    def valid
+      true
+    end
+  end
+end

data/app/models/glysellin/order_item.rb

@@ -0,0 +1,38 @@
+module Glysellin
+  class OrderItem < ActiveRecord::Base
+    self.table_name = 'glysellin_order_items'
+    belongs_to :order, inverse_of: :products
+
+    attr_accessible :sku, :name, :eot_price, :vat_rate, :bundle, :price,
+      :quantity, :weight
+
+    # The attributes we getch from a product to build our order item
+    PRODUCT_ATTRIBUTES_FOR_ITEM = %w(sku name eot_price vat_rate price weight)
+
+    class << self
+      # Create an item from product or bundle id
+      #
+      # @param [String] id The id string of the item
+      # @param [Boolean] bundle If it's a bundle or just one product
+      #
+      # @return [OrderItem] The created order item
+      def build_from_product id, quantity
+        product = Glysellin::Variant.find_by_id(id)
+
+        attrs = PRODUCT_ATTRIBUTES_FOR_ITEM.map do |key|
+          [key, product.public_send(key)]
+        end
+
+        OrderItem.new(Hash[attrs].merge('quantity' => quantity))
+      end
+    end
+
+    def total_eot_price
+      quantity * eot_price
+    end
+
+    def total_price
+      quantity * price
+    end
+  end
+end

data/app/models/glysellin/orderer.rb

@@ -0,0 +1,28 @@
+module Glysellin
+  module Orderer
+    extend ActiveSupport::Concern
+
+    included do
+      has_one :billing_address, class_name: 'Glysellin::Address',
+        as: :billed_addressable, dependent: :destroy, autosave: true
+
+      has_one :shipping_address, class_name: 'Glysellin::Address',
+        as: :shipped_addressable, dependent: :destroy, autosave: true
+
+      attr_writer :use_another_address_for_shipping
+
+      attr_accessible :billing_address_attributes, :shipping_address_attributes,
+        :use_another_address_for_shipping
+
+      accepts_nested_attributes_for :billing_address, :shipping_address
+    end
+
+    def use_another_address_for_shipping
+      !(shipping_address.new_record? && !super) rescue false
+    end
+
+    def has_shipping_address?
+      shipping_address && shipping_address.id.present?
+    end
+  end
+end

data/app/models/glysellin/payment.rb

@@ -0,0 +1,46 @@
+module Glysellin
+  class Payment < ActiveRecord::Base
+    self.table_name = 'glysellin_payments'
+
+    belongs_to :order, :inverse_of => :payments
+    belongs_to :type, :class_name => 'PaymentMethod', :foreign_key => 'type_id', :inverse_of => :payments
+
+    attr_accessible :status, :type_id, :type, :order, :order_id,
+      :last_payment_action_on, :transaction_id
+
+    # Public: Status const to be used if payment pending
+    PAYMENT_STATUS_PENDING = 'pending'
+    # Public: Status const to be used if payment paid
+    PAYMENT_STATUS_PAID = 'paid'
+    # Public: Status const to be used if payment canceled
+    PAYMENT_STATUS_CANCELED = 'canceled'
+
+    def new_status s
+      self.status = s
+      self.last_payment_action_on = Time.now
+      self.save
+    end
+
+    def new_transaction_id!
+      last_transaction_with_id = self.class.where('transaction_id > 0').order('updated_at DESC').first
+      next_id = last_transaction_with_id ? last_transaction_with_id.transaction_id + 1 : 1
+      self.transaction_id = next_id
+      self.save
+    end
+
+    def get_new_transaction_id
+      self.new_transaction_id!
+      self.transaction_id
+    end
+
+    def status_enum
+      [PAYMENT_STATUS_PAID, PAYMENT_STATUS_PENDING, PAYMENT_STATUS_CANCELED].map do |s|
+        [I18n.t("glysellin.labels.payments.statuses.#{ s }"), s]
+      end
+    end
+
+    def by_check?
+      type.slug == 'check'
+    end
+  end
+end

data/app/models/glysellin/payment_method.rb

@@ -0,0 +1,36 @@
+module Glysellin
+  class PaymentMethod < ActiveRecord::Base
+    self.table_name = 'glysellin_payment_methods'
+    has_many :payments, :foreign_key => 'type_id'
+
+    attr_accessible :name, :slug
+
+    scope :ordered, order("name ASC")
+
+    class << self
+      def gateway_from_order_ref ref
+        order = Order.find_by_ref(ref)
+        gateway_for(order)
+      end
+
+      def gateway_from_raw_post gateway, raw_post
+        order = Glysellin.gateways[gateway].parse_order_id(raw_post)
+        gateway_for(order)
+      end
+
+      def gateway_for order
+        Glysellin.gateways[order.payment_method.slug].new(order)
+      end
+    end
+
+    # Get the payment request button HTML for the specified order
+    #
+    # @param [Order] order The order to get the payment request for
+    #
+    # @return [String] The request button HTML
+    def request_button order
+      g = Glysellin.gateways[order.payment_method.slug].new(order)
+      g.render_request_button
+    end
+  end
+end

data/app/models/glysellin/product.rb

@@ -0,0 +1,136 @@
+require 'digest/sha1'
+require 'friendly_id'
+
+module Glysellin
+  class Product < ActiveRecord::Base
+    include ProductMethods
+    extend FriendlyId
+
+    friendly_id :name, use: :slugged
+
+    self.table_name = 'glysellin_products'
+
+    # Relations
+    #
+    # The ProductImage model is used for products and bundles with the same
+    has_many :images, as: :imageable, class_name: 'Glysellin::ProductImage',
+      inverse_of: :imageable, dependent: :destroy
+
+    # Can have multiple taxonomies
+    has_and_belongs_to_many :taxonomies, :class_name => 'Glysellin::Taxonomy',
+      join_table: 'glysellin_products_taxonomies', :foreign_key => 'product_id'
+
+    # N..N relation between bundles and products
+    # has_many :bundle_products, class_name: 'Glysellin::BundleProduct',
+    #   foreign_key: 'product_id'
+    # has_many :bundles, class_name: 'Glysellin::Product',
+    #   through: :bundle_products
+
+    # # Bundled products in current_product
+    # has_many :product_bundles, class_name: 'Glysellin::BundleProduct',
+    #   foreign_key: 'bundle_id'
+    # has_many :bundled_products, class_name: 'Glysellin::Product',
+    #   through: :product_bundles
+
+    # Products can belong to a brand
+    belongs_to :brand, :inverse_of => :products
+
+    belongs_to :product_type
+
+    has_many :variants, class_name: 'Glysellin::Variant',
+      before_add: :set_product_on_variant, dependent: :destroy
+
+    accepts_nested_attributes_for :images, allow_destroy: true, reject_if: :all_blank
+    accepts_nested_attributes_for :variants, allow_destroy: true, reject_if: :all_blank
+
+    # accepts_nested_attributes_for :bundled_products, allow_destroy: true, reject_if: :all_blank
+
+    attr_accessible :description, :name, :sku, :slug, :vat_rate,
+      :brand, :taxonomies, :images, :published,
+      :display_priority, :images_attributes, :taxonomy_ids, :unlimited_stock,
+      :position, :brand_id, :variants_attributes, :variants, :product_type_id
+
+      # :bundled_products_attributes
+
+    # Validations
+    #
+    validates_presence_of :name, :slug
+    # Validates price related attributes only unless we have bundled products
+    # so we can defer validations to them
+    validates :vat_rate, presence: true,
+      numericality: true # , unless: proc { |p| p.bundled_products.length > 0 }
+
+    # We check presence of sku if set in global config
+    validates :sku, presence: true, if: proc { Glysellin.autoset_sku }
+
+    # Callbacks
+    #
+    before_validation :set_sku, :set_vat_rate, :ensure_variant
+
+    scope :published, where('glysellin_products.published = ?', true)
+    scope :with_taxonomy, lambda { |*taxonomies|
+      # Ensure we only have slugs so we got a string vector
+      taxonomies.map! { |t| t.kind_of?(Glysellin::Taxonomy) ? t.slug : t }
+      # Get products with those taxonomies
+      includes(:taxonomies).where('glysellin_taxonomies.slug IN (?)', taxonomies)
+    }
+
+    # Master variant methods delegation
+    delegate :price, :unmarked_price, :marked_down?, to: :master_variant
+
+
+    # And as for the validation, if the SKU is configured to be autoset,
+    # we check generate it
+    def set_sku
+      unless (sku && sku.length > 0) || !Glysellin.autoset_sku
+        self.sku = generate_sku
+      end
+    end
+
+    def set_vat_rate
+      if !vat_rate
+        self.vat_rate = Glysellin.default_vat_rate
+      end
+    end
+
+    def ensure_variant
+      variants.build(product: self) unless variants.length > 0
+    end
+
+    # Fetches all available variants for the current product
+    #
+    def available_variants
+      variants.available
+    end
+
+    def image
+      images.length > 0 ? images.first.image : nil
+    end
+
+    def master_variant
+      self.variants.first
+    end
+
+    def set_product_on_variant variant
+      variant.product = self
+    end
+
+    # bundle_attribute :price do |product|
+    #   product.bundled_products.reduce(0) do |total, product|
+    #     total + product.price
+    #   end
+    # end
+
+    # bundle_attribute :eot_price do |product, att|
+    #   product.bundled_products.reduce(0) do |total, product|
+    #     total + product.eot_price
+    #   end
+    # end
+
+    # bundle_attribute :vat_rate do |product|
+    #   product.bundled_products.reduce(0) do |total, product|
+    #     total + (product.vat_rate * product.price)
+    #   end / product.price
+    # end
+  end
+end