comable_core 0.3.4 → 0.4.0

data/app/models/comable/shipment.rb

@@ -0,0 +1,79 @@
+module Comable
+  class Shipment < ActiveRecord::Base
+    include Comable::Ransackable
+
+    belongs_to :order, class_name: Comable::Order.name, inverse_of: :shipment
+    belongs_to :shipment_method, class_name: Comable::ShipmentMethod.name
+
+    before_validation :copy_attributes_from_shipment_method, unless: :order_completed?
+
+    validates :order, presence: true
+    validates :shipment_method, presence: true
+    validates :fee, presence: true, numericality: { greater_than_or_equal_to: 0 }
+    validates :tracking_number, length: { maximum: 255 }
+
+    delegate :name, to: :shipment_method
+
+    ransack_options ransackable_attributes: { except: [:order_id, :shipment_method_id] }
+
+    # The #state attribute assigns the following values:
+    #
+    # pending   when Order is not able to ship (default)
+    # ready     when Order is able to ship
+    # completed when Order is already shipped
+    # canceled  when Order is canceled
+    # resumed   when Order is resumed from the "canceled" state
+    state_machine initial: :pending do
+      state :pending
+      state :ready
+      state :completed
+      state :canceled
+      state :resumed
+
+      event :next_state do
+        transition :pending => :ready
+        transition :ready => :completed
+      end
+
+      event :ship do
+        transition :ready => :completed
+      end
+
+      event :cancel do
+        transition [:completed, :resumed] => :canceled
+      end
+
+      event :resume do
+        transition :canceled => :resumed
+      end
+    end
+
+    class << self
+      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 completed?
+      state?(:completed) || state?(:resumed)
+    end
+
+    private
+
+    def order_completed?
+      order.completed?
+    end
+
+    def copy_attributes_from_shipment_method
+      self.attributes = {
+        fee: shipment_method.fee
+      }
+    end
+  end
+end

data/app/models/comable/stock/csvable.rb

@@ -0,0 +1,26 @@
+module Comable
+  class Stock < ActiveRecord::Base
+    module Csvable
+      extend ActiveSupport::Concern
+
+      include Comable::Importable
+
+      included do
+        comma do
+          product_code
+          code
+          quantity
+          sku_h_choice_name
+          sku_v_choice_name
+        end
+      end
+
+      delegate :code, to: :product, prefix: true, allow_nil: true
+
+      def product_code=(code)
+        return if product_code == code
+        self.product = Comable::Product.find_by(code: code)
+      end
+    end
+  end
+end

data/app/models/comable/stock.rb

@@ -7,6 +7,7 @@ module Comable
     include Comable::SkuItem
     include Comable::SkuChoice
     include Comable::Ransackable
+    include Comable::Stock::Csvable
 
     belongs_to :product, class_name: Comable::Product.name
 
@@ -18,25 +19,15 @@ module Comable
     # 品切れでない在庫インスタンスを返す
     scope :stocked, -> { where('quantity > ?', 0) }
 
-    class << self
-      alias_method :unsold, :stocked
-      deprecate :unsold, deprecator: Comable::Deprecator.instance
-    end
-
     # @!scope class
     # 品切れの在庫インスタンスを返す
     scope :unstocked, -> { where('quantity <= ?', 0) }
 
-    class << self
-      alias_method :soldout, :unstocked
-      deprecate :soldout, deprecator: Comable::Deprecator.instance
-    end
-
     #
     # @!endgroup
     #
 
-    validates :product, presence: true
+    validates :product, presence: { message: Comable.t('admin.is_not_exists') }
     validates :code, presence: true, length: { maximum: 255 }
     validates :sku_h_choice_name, length: { maximum: 255 }
     validates :sku_v_choice_name, length: { maximum: 255 }
@@ -63,9 +54,6 @@ module Comable
       (self.quantity - quantity) >= 0
     end
 
-    alias_method :unsold?, :stocked?
-    deprecate :unsold?, deprecator: Comable::Deprecator.instance
-
     # 在庫の有無を取得する
     #
     # @example
@@ -78,8 +66,5 @@ module Comable
     def unstocked?(quantity: 1)
       !stocked?(quantity: quantity)
     end
-
-    alias_method :soldout?, :unstocked?
-    deprecate :soldout?, deprecator: Comable::Deprecator.instance
   end
 end

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(activate_flag: true) }
+
+    enumerize :place, in: %i(
+      everywhere
+      checkout
+    ), scope: true
+  end
+end

data/app/models/comable/{customer.rb → user.rb}

@@ -1,5 +1,5 @@
 module Comable
-  class Customer < ActiveRecord::Base
+  class User < ActiveRecord::Base
     include Comable::CartOwner
     include Comable::RoleOwner
     include Comable::Ransackable
@@ -15,7 +15,7 @@ module Comable
 
     validates :email, presence: true, length: { maximum: 255 }
 
-    devise(*Comable::Config.devise_strategies[:customer])
+    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] }
 
@@ -62,28 +62,21 @@ module Comable
     end
 
     def cart_items
-      @cart_items ||= incomplete_order.order_details
+      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 order(order_params = {})
-      Rails.logger.debug '[DEPRECATED] Comable::Customer#order is deprecated. Please use Comable::Order#next_state method.'
-      incomplete_order.attributes = order_params
-      incomplete_order.state = 'complete'
-      incomplete_order.complete!
-      incomplete_order.tap { reload }
-    end
-
     def after_set_user
       return unless current_guest_token
 
-      guest_order = Comable::Order.incomplete.preload(:order_details).where(guest_token: current_guest_token).first
+      guest_order = Comable::Order.incomplete.preload(:order_items).where(guest_token: current_guest_token).first
       return unless guest_order
 
-      inherit_order_state(guest_order)
+      incomplete_order.inherit!(guest_order)
       inherit_cart_items(guest_order)
     end
 
@@ -106,7 +99,7 @@ module Comable
 
     def incomplete_order_attributes
       {
-        customer_id: id,
+        user_id: id,
         email: email
       }
     end
@@ -115,20 +108,15 @@ module Comable
       guest_token ||= current_guest_token unless signed_in?
       Comable::Order
         .incomplete
-        .preload(:order_details)
+        .preload(:order_items)
         .where(guest_token: guest_token)
-        .by_customer(self)
+        .by_user(self)
         .first
     end
 
-    def inherit_order_state(guest_order)
-      return if incomplete_order.stated?(guest_order.state)
-      incomplete_order.next_state
-    end
-
     def inherit_cart_items(guest_order)
-      guest_order.order_details.each do |order_detail|
-        move_cart_item(order_detail)
+      guest_order.order_items.each do |order_item|
+        move_cart_item(order_item)
       end
     end
   end

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

@@ -10,52 +10,35 @@ module Comable
         state :shipment
         state :payment
         state :confirm
-        state :complete
+        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, :complete] => :confirm
-          transition :confirm => :complete
+          transition all - [:confirm, :completed] => :confirm
+          transition :confirm => :completed
         end
 
-        before_transition to: :complete do |order, _transition|
-          order.complete
+        event :cancel do
+          transition to: :canceled, from: [:completed, :resumed], if: :allow_cancel?
         end
-      end
-
-      # TODO: Remove with_options
-      with_options if: -> { state?(:cart) } do |context|
-        context.validates :customer_id, presence: true, uniqueness: { scope: [:customer_id, :completed_at] }, unless: :guest_token
-        context.validates :guest_token, presence: true, uniqueness: { scope: [:guest_token, :completed_at] }, unless: :customer
-      end
-
-      with_options if: -> { stated?(:cart) } do |context|
-        context.validates :email, presence: true
-      end
 
-      with_options if: -> { stated?(:orderer) } do |context|
-        context.validates :bill_address, presence: true
-      end
-
-      with_options if: -> { stated?(:delivery) } do |context|
-        context.validates :ship_address, presence: true
-      end
-
-      with_options if: -> { stated?(:payment) && payment_required? } do |context|
-        context.validates :payment_method, presence: true
-      end
+        event :return do
+          transition to: :returned, from: [:completed, :resumed], if: :allow_return?
+        end
 
-      with_options if: -> { stated?(:shipment) && shipment_required? } do |context|
-        context.validates :shipment_method, presence: true
-      end
+        event :resume do
+          transition to: :resumed, from: :canceled
+        end
 
-      with_options if: -> { stated?(:complete) } do |context|
-        context.validates :code, presence: true
-        context.validates :shipment_fee, presence: true
-        context.validates :total_price, presence: true
+        before_transition to: :completed, do: :complete!
+        after_transition to: :canceled, do: :restock!
+        after_transition to: :resumed, do: :unstock!
       end
     end
 
@@ -71,6 +54,10 @@ module Comable
       target_state_index < current_state_index
     end
 
+    def completed?
+      state?(:completed) || state?(:resumed)
+    end
+
     def orderer_required?
       bill_address.nil? || bill_address.new_record?
     end
@@ -80,11 +67,23 @@ module Comable
     end
 
     def payment_required?
-      Comable::PaymentMethod.exists?
+      Comable::PaymentMethod.exists? && payment.nil?
     end
 
     def shipment_required?
-      Comable::ShipmentMethod.activated.exists?
+      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/views/comable/order_mailer/complete.text.erb

@@ -6,10 +6,10 @@
 
 <%= Comable.t('order_mailer.complete.introductions', store_name: current_store.name) %>
 
-    <%- shipment_method = @order.shipment_method %>
-    <%- if shipment_method %>
-    <%= shipment_method.class.model_name.human %>:
-            <%= shipment_method.name %>
+    <%- shipment = @order.shipment %>
+    <%- if shipment %>
+    <%= @order.class.human_attribute_name(:shipment_method) %>:
+            <%= shipment.name %>
     <%- end %>
 
     <%= @order.class.human_attribute_name(:ship_address) %>:
@@ -22,19 +22,20 @@
 <%= "#{@order.class.human_attribute_name(:code)}: #{@order.code}" %>
 <%= "#{@order.class.human_attribute_name(:completed_at)}: #{I18n.l @order.completed_at.to_date}" %>
 
-<%- @order.order_details.each do |order_detail| %>
-            <%= name_with_quantity order_detail.name_with_sku, order_detail.quantity %>
-            <%= number_to_currency order_detail.subtotal_price %>
+<%- @order.order_items.each do |order_item| %>
+            <%= name_with_quantity order_item.name_with_sku, order_item.quantity %>
+            <%= number_to_currency order_item.subtotal_price %>
 
 <%- end %>
 ----------------------------------------------------------------------
 
             <%= "#{@order.class.human_attribute_name(:item_total_price)}: #{number_to_currency @order.item_total_price}" %>
+            <%= "#{@order.class.human_attribute_name(:payment_fee)}: #{number_to_currency @order.payment_fee}" %>
             <%= "#{@order.class.human_attribute_name(:shipment_fee)}: #{number_to_currency @order.shipment_fee}" %>
 
             <%= "#{@order.class.human_attribute_name(:total_price)}: #{number_to_currency @order.total_price}" %>
 
-            <%= "#{@order.class.human_attribute_name(:payment_method)}: #{@order.payment_method.name}\n" if @order.payment_method -%>
+            <%= "#{@order.class.human_attribute_name(:payment_method)}: #{@order.payment.name}\n" if @order.payment -%>
 
 ======================================================================
 

data/config/initializers/comma.rb

@@ -0,0 +1,8 @@
+# from https://github.com/comma-csv/comma/pull/50#issuecomment-22819269
+Comma::HeaderExtractor.value_humanizer = lambda do |value, model_class|
+  if value.is_a?(String) || !model_class.respond_to?(:human_attribute_name)
+    Comma::HeaderExtractor::DEFAULT_VALUE_HUMANIZER.call(value, model_class)
+  else
+    model_class.human_attribute_name(value)
+  end
+end