comable-core 0.6.0

data/app/models/comable/tracker.rb

@@ -0,0 +1,17 @@
+module Comable
+  class Tracker < ActiveRecord::Base
+    extend Enumerize
+
+    validates :name, presence: true, length: { maximum: 255 }
+    validates :tracker_id, length: { maximum: 255 }
+    validates :code, presence: true
+    validates :place, presence: true, length: { maximum: 255 }
+
+    scope :activated, -> { where(activated_flag: true) }
+
+    enumerize :place, in: %i(
+      everywhere
+      checkout
+    ), scope: true
+  end
+end

data/app/models/comable/user.rb

@@ -0,0 +1,130 @@
+module Comable
+  class User < ActiveRecord::Base
+    include Comable::CartOwner
+    include Comable::RoleOwner
+    include Comable::Ransackable
+    include Comable::Liquidable
+
+    has_many :orders, class_name: Comable::Order.name
+    has_many :addresses, class_name: Comable::Address.name, dependent: :destroy
+    belongs_to :bill_address, class_name: Comable::Address.name, dependent: :destroy
+    belongs_to :ship_address, class_name: Comable::Address.name, dependent: :destroy
+
+    accepts_nested_attributes_for :addresses
+    accepts_nested_attributes_for :bill_address
+    accepts_nested_attributes_for :ship_address
+
+    scope :this_month, -> { where(created_at: Time.now.beginning_of_month..Time.now.end_of_month) }
+    scope :this_week, -> { where(created_at: Time.now.beginning_of_week..Time.now.end_of_week) }
+    scope :last_week, -> { where(created_at: 1.week.ago.beginning_of_week..1.week.ago.end_of_week) }
+
+    validates :email, presence: true, length: { maximum: 255 }
+
+    devise(*Comable::Config.devise_strategies[:user])
+
+    ransack_options ransackable_attributes: { except: [:encrypted_password, :reset_password_token, :reset_password_sent_at, :remember_created_at, :bill_address_id, :ship_address_id] }
+
+    liquid_methods :email, :bill_full_name, :ship_full_name, :cart
+
+    delegate :full_name, to: :bill_address, allow_nil: true, prefix: :bill
+    delegate :full_name, to: :ship_address, allow_nil: true, prefix: :ship
+
+    def with_cookies(cookies)
+      @cookies = cookies
+      self
+    end
+
+    # Add conditions for the orders association.
+    # Override method of the orders association to support Rails 3.x.
+    def orders
+      super.complete.order('completed_at DESC, id DESC')
+    end
+
+    def other_addresses
+      addresses - [bill_address] - [ship_address]
+    end
+
+    def update_bill_address_by(bill_address)
+      update_attributes(bill_address: addresses.find_or_clone(bill_address))
+    end
+
+    def update_ship_address_by(ship_address)
+      update_attributes(ship_address: addresses.find_or_clone(ship_address))
+    end
+
+    def signed_in?
+      !new_record?
+    end
+
+    def not_signed_in?
+      !signed_in?
+    end
+
+    # TODO: Add a test case
+    def reload(*_)
+      super.tap do
+        @cart_items = nil
+        @incomplete_order = nil
+      end
+    end
+
+    def cart_items
+      incomplete_order.order_items
+    end
+
+    def incomplete_order
+      @incomplete_order = nil if @incomplete_order.try(:completed?)
+      @incomplete_order ||= find_incomplete_order || initialize_incomplete_order
+    end
+
+    def after_set_user
+      return unless current_guest_token
+
+      guest_order = Comable::Order.incomplete.preload(:order_items).where(guest_token: current_guest_token).first
+      return unless guest_order
+
+      incomplete_order.inherit!(guest_order)
+      inherit_cart_items(guest_order)
+    end
+
+    def human_id
+      "##{id}"
+    end
+
+    private
+
+    def current_guest_token
+      @cookies.signed[:guest_token] if @cookies
+    end
+
+    def initialize_incomplete_order
+      order = Comable::Order.create(incomplete_order_attributes)
+      @cookies.permanent.signed[:guest_token] = order.guest_token if @cookies
+      # enable preload
+      find_incomplete_order
+    end
+
+    def incomplete_order_attributes
+      {
+        user_id: id,
+        email: email
+      }
+    end
+
+    def find_incomplete_order
+      guest_token ||= current_guest_token unless signed_in?
+      Comable::Order
+        .incomplete
+        .preload(:order_items)
+        .where(guest_token: guest_token)
+        .by_user(self)
+        .first
+    end
+
+    def inherit_cart_items(guest_order)
+      guest_order.order_items.each do |order_item|
+        move_cart_item(order_item)
+      end
+    end
+  end
+end

data/app/models/concerns/comable/cart_owner.rb

@@ -0,0 +1,94 @@
+module Comable
+  module CartOwner
+    def add_cart_item(obj, quantity: 1)
+      process_cart_item(obj) do |stock|
+        add_stock_to_cart(stock, quantity)
+      end
+    end
+
+    def remove_cart_item(obj, quantity: -1)
+      add_cart_item(obj, quantity: quantity)
+    end
+
+    def reset_cart_item(obj, quantity: 0)
+      process_cart_item(obj) do |stock|
+        reset_stock_from_cart(stock, quantity)
+      end
+    end
+
+    def move_cart_item(cart_item)
+      add_cart_item(cart_item.stock, quantity: cart_item.quantity) && cart_item.destroy
+    end
+
+    def cart_items
+      fail 'You should implement cart_items method.'
+    end
+
+    def cart
+      Cart.new(cart_items)
+    end
+
+    class Cart < Array
+      def price
+        sum(&:current_subtotal_price)
+      end
+
+      def count
+        sum(&:quantity)
+      end
+
+      alias_method :size, :count
+
+      # TODO: Refactoring
+      def errors
+        ActiveModel::Errors.new(self).tap do |obj|
+          map(&:errors).map(&:full_messages).flatten.each do |full_message|
+            obj[:base] << full_message
+          end
+        end
+      end
+    end
+
+    private
+
+    def process_cart_item(obj)
+      case obj
+      when Comable::Product
+        yield obj.stocks.first
+      when Comable::Stock
+        yield obj
+      when Array
+        obj.map { |item| yield item }
+      else
+        fail
+      end
+    end
+
+    def add_stock_to_cart(stock, quantity)
+      cart_item = find_cart_item_by(stock)
+      if cart_item
+        cart_item.quantity += quantity
+        (cart_item.quantity > 0) ? cart_item.save : cart_item.destroy
+      else
+        cart_items.build(stock_id: stock.id, quantity: quantity).save
+      end
+    end
+
+    def reset_stock_from_cart(stock, quantity)
+      cart_item = find_cart_item_by(stock)
+      if quantity > 0
+        return add_stock_to_cart(stock, quantity) unless cart_item
+        cart_item.update_attributes(quantity: quantity)
+      else
+        return false unless cart_item
+        cart_items.destroy(cart_item)
+      end
+    end
+
+    def find_cart_item_by(stock)
+      # TODO: Refactoring
+      fail unless stock.is_a?(Comable::Stock)
+      cart_items.find { |cart_item| cart_item.stock.id == stock.id }
+    end
+  end
+end

data/app/models/concerns/comable/checkout.rb

@@ -0,0 +1,85 @@
+module Comable
+  module Checkout
+    extend ActiveSupport::Concern
+
+    included do
+      state_machine initial: :cart do
+        state :cart
+        state :orderer
+        state :delivery
+        state :shipment
+        state :payment
+        state :confirm
+        state :completed
+        state :canceled
+        state :returned
+        state :resumed
+
+        event :next_state do
+          transition :cart => :orderer, if: :orderer_required?
+          transition [:cart, :orderer] => :delivery, if: :delivery_required?
+          transition [:cart, :orderer, :delivery] => :shipment, if: :shipment_required?
+          transition [:cart, :orderer, :delivery, :shipment] => :payment, if: :payment_required?
+          transition all - [:confirm, :completed] => :confirm
+          transition :confirm => :completed
+        end
+
+        event :cancel do
+          transition to: :canceled, from: [:completed, :resumed], if: :allow_cancel?
+        end
+
+        event :return do
+          transition to: :returned, from: [:completed, :resumed], if: :allow_return?
+        end
+
+        event :resume do
+          transition to: :resumed, from: :canceled
+        end
+
+        before_transition to: :completed, do: :complete!
+        after_transition to: :canceled, do: :restock!
+        after_transition to: :resumed, do: :unstock!
+      end
+    end
+
+    module ClassMethods
+      def state_names
+        state_machine.states.keys
+      end
+    end
+
+    def stated?(target_state)
+      target_state_index = self.class.state_names.index(target_state.to_sym)
+      current_state_index = self.class.state_names.index(state_name)
+      target_state_index < current_state_index
+    end
+
+    def orderer_required?
+      bill_address.nil? || bill_address.new_record?
+    end
+
+    def delivery_required?
+      ship_address.nil? || ship_address.new_record?
+    end
+
+    def payment_required?
+      Comable::PaymentMethod.exists? && payment.nil?
+    end
+
+    def shipment_required?
+      Comable::ShipmentMethod.activated.exists? && shipment.nil?
+    end
+
+    def allow_cancel?
+      # TODO: Implement shipments
+      # !shipments.exists?
+      true
+    end
+
+    def allow_return?
+      # TODO: Implement shipments
+      # shipments.exists?
+      false
+    end
+  end
+end

data/app/models/concerns/comable/importable.rb

@@ -0,0 +1,67 @@
+module Comable
+  module Importable
+    extend ActiveSupport::Concern
+
+    class Exception < StandardError
+    end
+
+    class UnknownFileType < Comable::Importable::Exception
+    end
+
+    class RecordInvalid < Comable::Importable::Exception
+    end
+
+    # from http://railscasts.com/episodes/396-importing-csv-and-excel
+    module ClassMethods
+      def import_from(file, primary_key: :code)
+        spreadsheet = open_spreadsheet(file)
+        read_spreadsheet(spreadsheet) do |header, row|
+          attributes = attributes_from_header_and_row(header, row)
+          record = find_by(primary_key => attributes[primary_key]) || new
+          begin
+            record.update_attributes!(attributes)
+          rescue ActiveRecord::RecordInvalid => e
+            raise RecordInvalid, "#{record.class.human_attribute_name(primary_key)} \"#{record.send(primary_key)}\": #{e.message}"
+          end
+        end
+      end
+
+      private
+
+      def open_spreadsheet(file)
+        case File.extname(file.original_filename)
+        when '.csv' then Roo::CSV.new(file.path)
+        when '.xls' then Roo::Excel.new(file.path, nil, :ignore)
+        when '.xlsx' then Roo::Excelx.new(file.path, nil, :ignore)
+        else fail UnknownFileType, Comable.t('admin.unknown_file_type', filename: file.original_filename)
+        end
+      end
+
+      def read_spreadsheet(spreadsheet)
+        header = spreadsheet.row(1)
+        (2..spreadsheet.last_row).each do |i|
+          yield header, spreadsheet.row(i)
+        end
+      end
+
+      def attributes_from_header_and_row(header, row)
+        human_attributes = Hash[[header, row].transpose].to_hash
+        human_attributes_to_attributes(human_attributes)
+      end
+
+      def human_attributes_to_attributes(human_attributes)
+        comma_column_names.each.with_object({}) do |(key, _value), result|
+          human_key = Comma::HeaderExtractor.value_humanizer.call(key.to_sym, self)
+          result[key.to_sym] = human_attributes[human_key] if human_attributes[human_key]
+          result
+        end
+      end
+
+      def comma_column_names(style = :default)
+        header_extractor_class = Comma::HeaderExtractor.dup
+        header_extractor_class.value_humanizer = -> (value, _model_class) { value.to_s }
+        extract_with(header_extractor_class, style)
+      end
+    end
+  end
+end

data/app/models/concerns/comable/liquidable.rb

@@ -0,0 +1,12 @@
+module Comable
+  module Liquidable
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # from: http://www.codedisqus.com/0SHjkUjjgW/how-can-i-expose-all-available-liquid-methods-for-a-model.html
+      def available_liquid_methods
+        self::LiquidDropClass.public_instance_methods - Liquid::Drop.public_instance_methods
+      end
+    end
+  end
+end

data/app/models/concerns/comable/product/search.rb

@@ -0,0 +1,41 @@
+module Comable
+  class Product
+    module Search
+      extend ActiveSupport::Concern
+
+      SEARCH_COLUMNS = %i( code name caption )
+
+      module ClassMethods
+        def search(query)
+          keywords = parse_to_keywords(query)
+          return (Rails::VERSION::MAJOR == 3) ? scoped : all if keywords.empty?
+          where(keywords_to_arel(keywords))
+        end
+
+        private
+
+        def keywords_to_arel(keywords)
+          keywords.inject(nil) do |arel_chain, keyword|
+            arel = keyword_to_arel(keyword)
+            arel_chain ? arel_chain.and(arel) : arel
+          end
+        end
+
+        def keyword_to_arel(keyword)
+          SEARCH_COLUMNS.inject(nil) do |arel_chain, column|
+            arel = arel_table[column].matches("%#{keyword}%")
+            arel_chain ? arel_chain.or(arel) : arel
+          end
+        end
+
+        def parse_to_keywords(query)
+          return [] if query.blank?
+          query
+            .delete('%')
+            .tr('　', ' ')
+            .split(' ')
+        end
+      end
+    end
+  end
+end