comable_core 0.3.4 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eff5ae9b60000ce4171fd14e7848dc952cd084eb
-  data.tar.gz: dd80b2206c1d2ac96a99421760547bcc4bd0717f
+  metadata.gz: b3586df9a1e1a2267feb7f84f1658f21f92909b2
+  data.tar.gz: 94e817e742c94849a8eb08ebf7f8de9c983c3a33
 SHA512:
-  metadata.gz: d6ba4f76bc521aa0fb526ce74fbdcfe7020ae7ab1db57e911da4434fbc275917436bcb02a84af19b317dfda3de47cd85e21dd83e42d37a1da4519220f57595dc
-  data.tar.gz: 598942cd5f8e84f1cc2bd6fc2e51465d99e24474cbfa2c83b1e5fe44ae92254b4b0b2308e7fbfa8819cd2c2f0d35ddb4b589a9883b26ee101e543c5f9101948f
+  metadata.gz: 6b03e1b7ff2c55f92048da4ab2fa08fb7c503ea2e6d70da22eebf8b1cc8f98c6c2bfb11241811c76fce533cad8cdc1dc190bf158290f58cbda72555902498132
+  data.tar.gz: 7c24b354ae4934ba2670851b2390e18f1c292f9675cde73ac251bf0799e1d49b81f1d551926db6afed7dd6cc5074dae95c9542b76b0fc245b4a1e989cb36f75d

data/app/helpers/comable/application_helper.rb

@@ -4,15 +4,17 @@ module Comable
       @current_store ||= Comable::Store.instance
     end
 
-    # Override the devise method.
-    # The below codes move to core/lib/comable/core/engine.rb:
-    #
-    # def current_customer
-    #   ...
-    # end
+    def current_comable_user
+      resource = current_admin_user || current_user || Comable::User.new
+      resource.with_cookies(cookies)
+    end
 
     def current_order
-      current_customer.incomplete_order
+      current_comable_user.incomplete_order
+    end
+
+    def current_trackers
+      @curent_trackers ||= (controller_name == 'orders' && action_name == 'create') ? Comable::Tracker.activated : Comable::Tracker.activated.with_place(:everywhere)
     end
 
     def next_order_path
@@ -25,7 +27,7 @@ module Comable
     end
 
     def store_location
-      session[:customer_return_to] = request.fullpath.gsub('//', '/')
+      session[:user_return_to] = request.fullpath.gsub('//', '/')
     end
 
     def name_with_honorific(name)
@@ -41,14 +43,19 @@ module Comable
       ].join(' ')
     end
 
+    def liquidize(content, arguments)
+      string = Liquid::Template.parse(content).render(arguments.stringify_keys)
+      string.respond_to?(:html_safe) ? string.html_safe : string
+    end
+
     private
 
     def after_sign_in_path_for(_resource)
-      session.delete(:customer_return_to) || comable.root_path
+      session.delete(:user_return_to) || comable.root_path
     end
 
     def after_sign_out_path_for(_resource)
-      session.delete(:customer_return_to) || comable.root_path
+      session.delete(:user_return_to) || comable.root_path
     end
 
     def after_sign_up_path_for(resource)

data/app/models/comable/ability.rb

@@ -3,7 +3,7 @@ module Comable
     include CanCan::Ability
 
     def initialize(user)
-      user ||= Comable::Customer.new # guest user (not logged in)
+      user ||= Comable::User.new # guest user (not logged in)
 
       case user.role.to_sym
       when :admin

data/app/models/comable/address.rb

@@ -1,6 +1,6 @@
 module Comable
   class Address < ActiveRecord::Base
-    belongs_to :customer, class_name: Comable::Customer.name, autosave: false
+    belongs_to :user, class_name: Comable::User.name, autosave: false
 
     validates :family_name, presence: true, length: { maximum: 255 }
     validates :first_name, presence: true, length: { maximum: 255 }
@@ -25,7 +25,7 @@ module Comable
     end
 
     def attributes_without_id
-      attributes.except('id', 'customer_id')
+      attributes.except('id', 'user_id')
     end
 
     def full_name

data/app/models/comable/order/associations.rb

@@ -0,0 +1,22 @@
+module Comable
+  class Order < ActiveRecord::Base
+    module Associations
+      extend ActiveSupport::Concern
+
+      included do
+        belongs_to :user, class_name: Comable::User.name, autosave: false
+        belongs_to :bill_address, class_name: Comable::Address.name, autosave: true, dependent: :destroy
+        belongs_to :ship_address, class_name: Comable::Address.name, autosave: true, dependent: :destroy
+        has_many :order_items, dependent: :destroy, class_name: Comable::OrderItem.name, inverse_of: :order
+        has_one :payment, dependent: :destroy, class_name: Comable::Payment.name, inverse_of: :order
+        has_one :shipment, dependent: :destroy, class_name: Comable::Shipment.name, inverse_of: :order
+
+        accepts_nested_attributes_for :bill_address
+        accepts_nested_attributes_for :ship_address
+        accepts_nested_attributes_for :order_items
+        accepts_nested_attributes_for :payment
+        accepts_nested_attributes_for :shipment
+      end
+    end
+  end
+end

data/app/models/comable/order/callbacks.rb

@@ -0,0 +1,43 @@
+module Comable
+  class Order < ActiveRecord::Base
+    module Callbacks
+      extend ActiveSupport::Concern
+
+      included do
+        define_model_callbacks :complete
+
+        before_validation :generate_guest_token, on: :create
+        before_validation :clone_addresses_from_user, on: :create
+        before_complete :generate_code
+        after_complete :clone_addresses_to_user
+      end
+
+      def generate_code
+        self.code = loop do
+          random_token = "C#{Array.new(11) { rand(9) }.join}"
+          break random_token unless self.class.exists?(code: random_token)
+        end
+      end
+
+      def generate_guest_token
+        return if user
+        self.guest_token ||= loop do
+          random_token = SecureRandom.urlsafe_base64(nil, false)
+          break random_token unless self.class.exists?(guest_token: random_token)
+        end
+      end
+
+      def clone_addresses_from_user
+        return unless user
+        self.bill_address ||= user.bill_address.try(:clone)
+        self.ship_address ||= user.ship_address.try(:clone)
+      end
+
+      def clone_addresses_to_user
+        return unless user
+        user.update_bill_address_by bill_address
+        user.update_ship_address_by ship_address
+      end
+    end
+  end
+end

data/app/models/comable/order/scopes.rb

@@ -0,0 +1,17 @@
+module Comable
+  class Order < ActiveRecord::Base
+    module Scopes
+      extend ActiveSupport::Concern
+
+      included do
+        scope :complete, -> { where.not(completed_at: nil) }
+        scope :incomplete, -> { where(completed_at: nil) }
+        scope :by_user, -> (user) { where(user_id: user) }
+        scope :this_month, -> { where(completed_at: Time.now.beginning_of_month..Time.now.end_of_month) }
+        scope :this_week, -> { where(completed_at: Time.now.beginning_of_week..Time.now.end_of_week) }
+        scope :last_week, -> { where(completed_at: 1.week.ago.beginning_of_week..1.week.ago.end_of_week) }
+        scope :recent, -> { order('completed_at DESC, id DESC') }
+      end
+    end
+  end
+end

data/app/models/comable/order/validations.rb

@@ -0,0 +1,39 @@
+module Comable
+  class Order < ActiveRecord::Base
+    module Validations
+      extend ActiveSupport::Concern
+
+      included do
+        validates :user_id, uniqueness: { scope: :completed_at }, if: :user
+        validates :guest_token, presence: true, uniqueness: { scope: :completed_at }, unless: :user
+
+        with_options if: -> { stated?(:cart) } do |context|
+          context.validates :email, presence: true, length: { maximum: 255 }
+        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?(:shipment) && shipment_required? } do |context|
+          context.validates :shipment, presence: true
+        end
+
+        with_options if: -> { stated?(:payment) && payment_required? } do |context|
+          context.validates :payment, presence: true
+        end
+
+        with_options if: -> { stated?(:confirm) } do |context|
+          context.validates :code, presence: true
+          context.validates :payment_fee, presence: true
+          context.validates :shipment_fee, presence: true
+          context.validates :total_price, presence: true
+        end
+      end
+    end
+  end
+end

data/app/models/comable/order.rb

@@ -1,125 +1,116 @@
+require_dependency 'comable/order/associations'
+require_dependency 'comable/order/callbacks'
+require_dependency 'comable/order/scopes'
+require_dependency 'comable/order/validations'
+require_dependency 'comable/order/morrisable'
+
 module Comable
   class Order < ActiveRecord::Base
     include Comable::Checkout
     include Comable::Ransackable
+    include Comable::Order::Associations
+    include Comable::Order::Callbacks
+    include Comable::Order::Scopes
+    include Comable::Order::Validations
     include Comable::Order::Morrisable
 
-    belongs_to :customer, class_name: Comable::Customer.name, autosave: false
-    belongs_to :payment_method, class_name: Comable::PaymentMethod.name, autosave: false
-    belongs_to :shipment_method, class_name: Comable::ShipmentMethod.name, autosave: false
-    belongs_to :bill_address, class_name: Comable::Address.name, autosave: true, dependent: :destroy
-    belongs_to :ship_address, class_name: Comable::Address.name, autosave: true, dependent: :destroy
-    has_many :order_details, dependent: :destroy, class_name: Comable::OrderDetail.name, inverse_of: :order
-
-    accepts_nested_attributes_for :bill_address
-    accepts_nested_attributes_for :ship_address
-    accepts_nested_attributes_for :order_details
-
-    define_model_callbacks :complete
-    before_validation :generate_guest_token, on: :create
-    before_validation :clone_addresses_from_customer, on: :create
-    after_complete :clone_addresses_to_customer
+    ransack_options attribute_select: { associations: [:payment, :shipment] }, ransackable_attributes: { except: [:bill_address_id, :ship_address_id] }
 
-    scope :complete, -> { where.not(completed_at: nil) }
-    scope :incomplete, -> { where(completed_at: nil) }
-    scope :by_customer, -> (customer) { where(customer_id: customer) }
-    scope :this_month, -> { where(completed_at: Time.now.beginning_of_month..Time.now.end_of_month) }
-    scope :this_week, -> { where(completed_at: Time.now.beginning_of_week..Time.now.end_of_week) }
-    scope :last_week, -> { where(completed_at: 1.week.ago.beginning_of_week..1.week.ago.end_of_week) }
-
-    ransack_options ransackable_attributes: { except: [:shipment_method_id, :payment_method_id, :bill_address_id, :ship_address_id] }
+    liquid_methods :code, :payment_fee, :shipment_fee, :item_total_price, :total_price
 
     delegate :full_name, to: :bill_address, allow_nil: true, prefix: :bill
     delegate :full_name, to: :ship_address, allow_nil: true, prefix: :ship
+    delegate :state, :human_state_name, to: :payment, allow_nil: true, prefix: true
+    delegate :state, :human_state_name, to: :shipment, allow_nil: true, prefix: true
 
-    def complete
+    def complete!
       ActiveRecord::Base.transaction do
         run_callbacks :complete do
-          save_to_complete.tap { |completed| self.completed_at = nil unless completed }
+          self.attributes = current_attributes
+
+          order_items.each(&:complete)
+          save!
+
+          payment.next_state! if payment
+          shipment.next_state! if shipment
+
+          touch(:completed_at)
         end
       end
     end
 
-    def complete!
-      Rails.logger.debug '[DEPRECATED] #complete! is deprecated. Please use #next_state method.'
-      fail Comable::InvalidOrder unless complete
-      self
-    end
+    alias_method :complete, :complete!
+    deprecate :complete, deprecator: Comable::Deprecator.instance
 
-    def completed?
-      !completed_at.nil?
+    def restock!
+      order_items.each(&:restock)
+      save!
     end
 
-    # TODO: switch to state_machine
-    def completing?
-      completed_at && completed_at_was.nil?
+    def unstock!
+      order_items.each(&:unstock)
+      save!
     end
 
     def stocked_items
-      order_details.to_a.select(&:unstocked?)
+      order_items.to_a.select(&:unstocked?)
     end
 
-    alias_method :soldout_stocks, :stocked_items
-    deprecate :soldout_stocks, deprecator: Comable::Deprecator.instance
-
     # 時価商品合計を取得
     def current_item_total_price
-      order_details.to_a.sum(&:current_subtotal_price)
+      order_items.to_a.sum(&:current_subtotal_price)
     end
 
     # 売価商品合計を取得
     def item_total_price
-      order_details.to_a.sum(&:subtotal_price)
+      order_items.to_a.sum(&:subtotal_price)
     end
 
     # 時価送料を取得
     def current_shipment_fee
-      shipment_method.try(:fee) || 0
+      shipment.try(:fee) || 0
+    end
+
+    # Get the current payment fee
+    def current_payment_fee
+      payment.try(:fee) || 0
     end
 
     # 時価合計を取得
     def current_total_price
-      current_item_total_price + current_shipment_fee
+      current_item_total_price + current_payment_fee + current_shipment_fee
     end
 
-    private
-
-    def save_to_complete
-      self.completed_at = Time.now
-      self.shipment_fee = current_shipment_fee
-      self.total_price = current_total_price
-      generate_code
+    # Inherit from other Order
+    def inherit!(order)
+      self.bill_address ||= order.bill_address
+      self.ship_address ||= order.ship_address
+      self.payment ||= order.payment
+      self.shipment ||= order.shipment
 
-      order_details.each(&:complete)
-
-      save
+      stated?(order.state) ? save! : next_state!
     end
 
-    def generate_code
-      self.code = loop do
-        random_token = "C#{Array.new(11) { rand(9) }.join}"
-        break random_token unless self.class.exists?(code: random_token)
-      end
+    def paid?
+      payment ? payment.completed? : true
     end
 
-    def generate_guest_token
-      return if customer
-      self.guest_token ||= loop do
-        random_token = SecureRandom.urlsafe_base64(nil, false)
-        break random_token unless self.class.exists?(guest_token: random_token)
-      end
+    def shipped?
+      shipment ? shipment.completed? : true
     end
 
-    def clone_addresses_from_customer
-      return unless customer
-      self.bill_address ||= customer.bill_address.try(:clone)
-      self.ship_address ||= customer.ship_address.try(:clone)
+    def can_ship?
+      shipment && shipment.ready? && paid? && completed?
     end
 
-    def clone_addresses_to_customer
-      return unless customer
-      customer.update_bill_address_by bill_address
-      customer.update_ship_address_by ship_address
+    private
+
+    def current_attributes
+      {
+        payment_fee: current_payment_fee,
+        shipment_fee: current_shipment_fee,
+        total_price: current_total_price
+      }
     end
   end
 end

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

@@ -0,0 +1,32 @@
+module Comable
+  class OrderItem < ActiveRecord::Base
+    module Csvable
+      extend ActiveSupport::Concern
+
+      included do
+        comma do
+          __association__ order: :code
+          __association__ order: :email
+          __association__ order: :payment_fee
+          __association__ order: :shipment_fee
+          __association__ order: :total_price
+          __association__ order: { bill_address: :family_name }
+          __association__ order: { bill_address: :first_name }
+          __association__ order: { bill_address: :zip_code }
+          __association__ order: { bill_address: :state_name }
+          __association__ order: { bill_address: :city }
+          __association__ order: { bill_address: :detail }
+          __association__ order: { bill_address: :phone_number }
+          name
+          code
+          price
+          sku_h_item_name
+          sku_v_item_name
+          sku_h_choice_name
+          sku_v_choice_name
+          quantity
+        end
+      end
+    end
+  end
+end

data/app/models/comable/{order_detail.rb → order_item.rb}

@@ -1,29 +1,36 @@
 module Comable
-  class OrderDetail < ActiveRecord::Base
+  class OrderItem < ActiveRecord::Base
     include Comable::SkuItem
     include Comable::SkuChoice
+    include Comable::OrderItem::Csvable
 
     belongs_to :stock, class_name: Comable::Stock.name, autosave: true
-    belongs_to :order, class_name: Comable::Order.name, inverse_of: :order_details
+    belongs_to :order, class_name: Comable::Order.name, inverse_of: :order_items
 
     validates :quantity, numericality: { greater_than: 0 }
     validate :valid_stock_quantity
 
+    liquid_methods :name, :name_with_sku, :code, :quantity, :price, :subtotal_price
+
     delegate :product, to: :stock
     delegate :image_url, to: :product
     delegate :guest_token, to: :order
     delegate :completed?, to: :order, allow_nil: true
-    delegate :completing?, to: :order, allow_nil: true
 
-    with_options if: -> { !completed? || completing? } do |incomplete|
-      incomplete.before_validation :copy_attributes
-    end
+    before_validation :copy_attributes, unless: :completed?
 
     def complete
-      copy_attributes
+      unstock
+    end
+
+    def unstock
       decrement_stock
     end
 
+    def restock
+      increment_stock
+    end
+
     # TODO: カート投入時との差額表示
     def copy_attributes
       self.attributes = current_attributes
@@ -50,9 +57,6 @@ module Comable
       end
     end
 
-    alias_method :soldout_stock?, :unstocked?
-    deprecate :soldout_stock?, deprecator: Comable::Deprecator.instance
-
     private
 
     def valid_stock_quantity
@@ -73,6 +77,11 @@ module Comable
       stock.quantity -= quantity
     end
 
+    def increment_stock
+      stock.lock!
+      stock.quantity += quantity
+    end
+
     def current_attributes
       {
         name: product.name,

data/app/models/comable/payment.rb

@@ -0,0 +1,82 @@
+module Comable
+  class Payment < ActiveRecord::Base
+    include Comable::Ransackable
+
+    belongs_to :order, class_name: Comable::Order.name, inverse_of: :payment
+    belongs_to :payment_method, class_name: Comable::PaymentMethod.name
+
+    before_validation :copy_attributes_from_payment_method, unless: :order_completed?
+
+    validates :order, presence: true
+    validates :payment_method, presence: true
+    validates :fee, presence: true, numericality: { greater_than_or_equal_to: 0 }
+
+    delegate :name, to: :payment_method
+    delegate :payment_provider, to: :payment_method
+    delegate :authorize!, :complete!, :cancel!, :resume!, to: :payment_provider, prefix: :provider
+
+    ransack_options ransackable_attributes: { except: [:order_id, :payment_method_id] }
+
+    # The #state attribute assigns the following values:
+    #
+    # pending   when Order is not able to pay (default)
+    # ready     when Order is able to pay
+    # completed when Order is already paid
+    # 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 :cancel do
+        transition [:completed, :resumed] => :canceled
+      end
+
+      event :resume do
+        transition :canceled => :resumed
+      end
+
+      after_transition to: :ready, do: :next_state!
+      before_transition to: :ready, do: -> (s) { s.provider_authorize! }
+      before_transition to: :completed, do: -> (s) { s.provider_complete! }
+      before_transition to: :canceled, do: -> (s) { s.provider_cancel! }
+      before_transition to: :canceled, do: -> (s) { s.provider_resume! }
+    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_payment_method
+      self.attributes = {
+        fee: payment_method.fee
+      }
+    end
+  end
+end

data/app/models/comable/payment_method.rb

@@ -3,6 +3,7 @@ module Comable
     validates :name, presence: true, length: { maximum: 255 }
     validates :payment_provider_type, presence: true, length: { maximum: 255 }
     validates :payment_provider_kind, presence: true, numericality: { greater_than_or_equal_to: 0 }
+    validates :fee, presence: true, numericality: { greater_than_or_equal_to: 0 }
     validates :enable_price_from, numericality: { greater_than_or_equal_to: 0, allow_blank: true }
     validates :enable_price_to, numericality: { greater_than_or_equal_to: 0, allow_blank: true }
 

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

@@ -0,0 +1,20 @@
+module Comable
+  class Product < ActiveRecord::Base
+    module Csvable
+      extend ActiveSupport::Concern
+
+      include Comable::Importable
+
+      included do
+        comma do
+          name
+          code
+          price
+          caption
+          sku_h_item_name
+          sku_v_item_name
+        end
+      end
+    end
+  end
+end

data/app/models/comable/product.rb

@@ -1,8 +1,9 @@
 module Comable
   class Product < ActiveRecord::Base
     include Comable::SkuItem
-    include Comable::Product::Search
     include Comable::Ransackable
+    include Comable::Product::Search
+    include Comable::Product::Csvable
 
     has_many :stocks, class_name: Comable::Stock.name, dependent: :destroy
     has_many :images, class_name: Comable::Image.name, dependent: :destroy
@@ -34,16 +35,10 @@ module Comable
       stocks.stocked.exists?
     end
 
-    alias_method :unsold?, :stocked?
-    deprecate :unsold?, deprecator: Comable::Deprecator.instance
-
     def unstocked?
       !stocked?
     end
 
-    alias_method :soldout?, :unstocked?
-    deprecate :soldout?, deprecator: Comable::Deprecator.instance
-
     def category_path_names=(category_path_names, delimiter: Comable::Category::DEFAULT_PATH_NAME_DELIMITER)
       self.categories = Comable::Category.find_by_path_names(category_path_names, delimiter: delimiter)
     end