rails_trade 0.0.1 → 0.0.2

data/app/models/rails_trade/buyer.rb

@@ -0,0 +1,35 @@
+module RailsTrade::Buyer
+  extend ActiveSupport::Concern
+
+  included do
+    attribute :name, :string
+
+    has_many :carts, as: :buyer, dependent: :destroy
+    has_many :orders, as: :buyer, inverse_of: :buyer, dependent: :nullify
+
+    has_many :promote_buyers, -> { valid }, as: :buyer, dependent: :destroy
+    has_many :promotes, through: :promote_buyers
+
+    has_many :payment_references, as: :buyer, dependent: :destroy, autosave: true
+    has_many :payment_methods, through: :payment_references, autosave: true
+
+    scope :credited, -> { where(payment_strategy_id: self.credit_ids) }
+  end
+
+  def name_detail
+    "#{name} (#{id})"
+  end
+
+  def last_overdue_date
+    orders.order(overdue_date: :asc).first&.overdue_date
+  end
+
+  class_methods do
+  
+    def credit_ids
+      PaymentStrategy.where.not(period: 0).pluck(:id)
+    end
+    
+  end
+
+end

data/app/models/rails_trade/cart.rb

@@ -0,0 +1,64 @@
+# 数据定期清理
+# 改变数据动作：
+#   * 新增(check)
+#   * 更新数量
+#   * 选择或更换优惠券
+#   * 选择服务
+module RailsTrade::Cart
+  extend ActiveSupport::Concern
+
+  included do
+    attribute :session_id, :string, limit: 128
+    attribute :amount, :decimal, precision: 10, scale: 2
+    attribute :trade_items_count, :integer, default: 0
+    attribute :retail_price, :decimal, default: 0, comment: '商品汇总的原价'
+    attribute :discount_price, :decimal, default: 0
+    attribute :bulk_price, :decimal, default: 0
+    attribute :reduced_amount, :decimal, default: 0, comment: '汇总的减少价格'
+    attribute :additional_amount, :decimal, default: 0
+    attribute :total_quantity, :decimal, default: 0
+    attribute :deposit_ratio, :integer, default: 100, comment: '最小预付比例'
+    attribute :payment_strategy_id, :integer
+    attribute :default, :boolean, default: false
+
+    belongs_to :organ, optional: true
+    belongs_to :user, optional: true
+    belongs_to :buyer, polymorphic: true, optional: true
+    belongs_to :payment_strategy, optional: true
+    has_many :orders, dependent: :nullify
+
+    validates :deposit_ratio, numericality: { only_integer: true, greater_than_or_equal_to: 0, less_than_or_equal_to: 100 }, allow_nil: true
+
+    validates :user_id, presence: true, if: -> { session_id.blank? }
+    validates :session_id, presence: true, if: -> { user_id.blank? }
+
+    after_update :set_default, if: -> { self.default? && saved_change_to_default? }
+  end
+
+  def compute_price
+    self.retail_price = trade_items.checked.sum(&:retail_price)
+    self.discount_price = trade_items.checked.sum(&:discount_price)
+    self.bulk_price = self.retail_price - self.discount_price
+
+    self.reduced_amount = trade_items.checked.sum(&:reduced_amount)
+    self.additional_amount = trade_items.checked.sum(&:additional_amount)
+
+    self.amount = trade_items.checked.sum(&:amount)
+
+    self.total_quantity = trade_items.checked.sum(&:original_quantity)
+    self
+  end
+
+  def set_default
+    self.class.where.not(id: self.id).where(user_id: self.user_id).update_all(default: false)
+  end
+
+  class_methods do
+
+    def default
+      find_by(default: true)
+    end
+
+  end
+
+end

data/app/models/rails_trade/good.rb

@@ -0,0 +1,71 @@
+module RailsTrade::Good
+  extend ActiveSupport::Concern
+  
+  included do
+    attribute :name, :string
+    attribute :sku, :string, default: -> { SecureRandom.hex }
+    attribute :price, :decimal, default: 0
+    attribute :advance_price, :decimal, default: 0
+    attribute :extra, :json, default: {}
+    attribute :unit, :string
+    attribute :quantity, :decimal, default: 0
+    attribute :unified_quantity, :decimal, default: 0
+    
+    has_many :trade_items, as: :trade, autosave: true, dependent: :destroy
+    has_many :orders, through: :trade_items, source: :trade
+
+    has_many :promote_goods, as: :good
+  end
+  
+  def final_price
+    compute_order_amount
+    #self.retail_price + self.promote_price
+  end
+
+  def valid_promote_goods
+    PromoteGood.valid.where(good_type: self.class.base_class.name, good_id: [nil, self.id]).where.not(promote_id: self.promote_goods.select(:promote_id).unavailable)
+  end
+
+  def default_promote_goods
+    PromoteGood.default.where(good_type: self.class.base_class.name, good_id: [nil, self.id])
+  end
+
+  def generate_order!(buyer: nil, cart: nil, maintain_id: nil, **params)
+    o = generate_order(buyer: buyer, cart: cart, maintain_id: maintain_id, **params)
+    o.check_state
+    o.save!
+    o
+  end
+
+  def generate_order(buyer: nil, cart: nil, maintain_id: nil, **params)
+    if buyer
+      o = buyer.orders.build
+    elsif cart
+      o = cart.orders.build
+    else
+      raise 'please assign buyer or cart'
+    end
+    
+    o.organ_id = self.organ_id if self.respond_to?(:organ_id)
+    if o.respond_to?(:maintain_id)
+      o.maintain_id = maintain_id
+      o.organ_id ||= o.maintain&.organ_id
+    end
+    
+    ti = o.trade_items.build(good: self)
+    ti.assign_attributes params.slice(:number)
+    ti.init_amount
+    ti.compute_promote
+    ti.sum_amount
+
+    o.assign_attributes params.slice(:extra, :currency)
+    o.compute_promote
+    o.compute_amount
+    o
+  end
+
+  def order_done
+    puts 'Should realize in good entity'
+  end
+
+end

data/app/models/rails_trade/order.rb

@@ -1,111 +1,98 @@
-class Order < ApplicationRecord
-  include ThePayment
-  include TheRefund
-  include PaymentInterfaceBase
-
-  belongs_to :payment_strategy, optional: true
-  belongs_to :buyer, optional: true
-  has_many :payment_orders, inverse_of: :order, dependent: :destroy
-  has_many :payments, through: :payment_orders, inverse_of: :orders
-  has_many :order_items, dependent: :destroy, autosave: true, inverse_of: :order
-  has_many :refunds, dependent: :nullify, inverse_of: :order
-  has_many :order_promotes, autosave: true, inverse_of: :order
-  has_many :order_serves, autosave: true
-  has_many :pure_order_promotes, -> { where(order_item_id: nil) }, class_name: 'OrderPromote'
-  has_many :pure_order_serves, -> { where(order_item_id: nil) }, class_name: 'OrderServe'
-
-  accepts_nested_attributes_for :order_items
-  accepts_nested_attributes_for :order_serves
-  accepts_nested_attributes_for :order_promotes
-
-  scope :credited, -> { where(payment_strategy_id: PaymentStrategy.where.not(period: 0).pluck(:id)) }
-  scope :to_pay, -> { where(payment_status: ['unpaid', 'part_paid']) }
-
-  after_initialize if: :new_record? do |o|
-    self.uuid = UidHelper.nsec_uuid('OD')
-    self.payment_status = 'unpaid'
-    self.buyer_id = self.user&.buyer_id if self.buyer_id.blank?
-    self.payment_strategy_id = self.buyer&.payment_strategy_id
-
-    compute_sum
-  end
-
-  after_create_commit :confirm_ordered!
-
-  enum payment_status: {
-    unpaid: 0,
-    part_paid: 1,
-    all_paid: 2,
-    refunding: 3,
-    refunded: 4,
-    denied: 5
-  }
+module RailsTrade::Order
+  extend ActiveSupport::Concern
+  include RailsTrade::Ordering::Payment
+  include RailsTrade::Ordering::Refund
+
+  included do
+    attribute :uuid, :string
+    attribute :state, :string
+    attribute :item_amount, :decimal, precision: 10, scale: 2
+    attribute :overall_additional_amount, :decimal, precision: 10, scale: 2
+    attribute :overall_reduced_amount, :decimal, precision: 10, scale: 2
+    attribute :amount, :decimal, precision: 10, scale: 2
+    attribute :received_amount, :decimal, precision: 10, scale: 2
+    attribute :payment_id, :integer, comment: 'for paypal'
+    attribute :myself, :boolean, default: true
+    attribute :note, :string, limit: 4096
+    attribute :expire_at, :datetime
+    attribute :payment_status, :string, default: 'unpaid', index: true
+    attribute :received_amount, :decimal, default: 0
+    attribute :expire_at, :datetime, default: -> { Time.current + RailsTrade.config.expire_after }
+    attribute :extra, :json, default: {}
+    attribute :currency, :string, default: RailsTrade.config.default_currency
+    attribute :trade_items_count, :integer, default: 0
+    attribute :lock_version, :integer
+
+    belongs_to :organ, optional: true
+    belongs_to :cart, optional: true
+    belongs_to :user, optional: true
+    belongs_to :payment_strategy, optional: true
+    has_many :payment_orders, dependent: :destroy
+    has_many :payments, through: :payment_orders, inverse_of: :orders
+    has_many :refunds, dependent: :nullify, inverse_of: :order
+
+    scope :credited, -> { where(payment_strategy_id: PaymentStrategy.where.not(period: 0).pluck(:id)) }
+    scope :to_pay, -> { where(payment_status: ['unpaid', 'part_paid']) }
+
+    enum payment_status: {
+      unpaid: 'unpaid',
+      part_paid: 'part_paid',
+      all_paid: 'all_paid',
+      refunding: 'refunding',
+      refunded: 'refunded',
+      denied: 'denied'
+    }
+
+    after_initialize if: :new_record? do
+      if cart
+        self.user_id = cart.user_id
+        self.payment_strategy_id = cart.payment_strategy_id
+      end
+    end
+    before_validation do
+      self.uuid ||= UidHelper.nsec_uuid('OD')
+    end
+    after_save :sync_from_cart, if: -> { saved_change_to_cart_id? && cart }
+    after_create_commit :confirm_ordered!
 
-  def extra
-    {}
+    delegate :url_helpers, to: 'Rails.application.routes'
   end
 
   def subject
-    order_items.map { |oi| oi.good&.name || 'Goods' }.join(', ')
+    trade_items.map { |oi| oi.good&.name || 'Goods' }.join(', ')
   end
 
-  def migrate_from_cart_item(cart_item_id)
-    cart_item = CartItem.find cart_item_id
-    self.user = cart_item.user
-    self.buyer = user.buyer
-    self.order_items.build(cart_item_id: cart_item_id, good_type: cart_item.good_type, good_id: cart_item.good_id, quantity: cart_item.quantity)
-
-    cart_item.total_serve_charges.each do |serve_charge|
-      self.order_serves.build(serve_charge_id: serve_charge.id, serve_id: serve_charge.serve_id, amount: serve_charge.subtotal)
-    end
-    cart_item.total_promote_charges.each do |promote_charge|
-      self.order_promotes.build(promote_charge_id: promote_charge.id, promote_id: promote_charge.promote_id, amount: promote_charge.subtotal)
-    end
-    compute_sum
+  def user_name
+    user&.name.presence || "#{user&.id}"
   end
 
-  def migrate_from_cart_items(cart_item_ids: nil)
-    cart_items = user.cart_items.checked.default_where(myself: self.myself)
-    cart_items.each do |cart_item|
-      self.order_items.build cart_item_id: cart_item.id, good_type: cart_item.good_type, good_id: cart_item.good_id, quantity: cart_item.quantity
-    end
-    init_with_default_serves
+  def amount_money
+    amounto_money(self.currency)
   end
 
-  def init_with_default_serves(cart_item_ids: nil)
-    summary = CartItem.checked_items(user_id: self.user_id, myself: self.myself, extra: self.extra)
-
-    summary.promote_charges.each do |promote_charge|
-      self.order_promotes.build(promote_charge_id: promote_charge.id, promote_id: promote_charge.promote_id, amount: promote_charge.subtotal)
-    end
-    summary.serve_charges.each do |serve_charge|
-      self.order_serves.build(serve_charge_id: serve_charge.id, serve_id: serve_charge.serve_id, amount: serve_charge.subtotal)
-    end
-    compute_sum
+  def compute_promote
   end
 
-  def compute_sum
-    _pure_order_serves = self.order_serves.select { |os| os.order_item_id.nil? }
-    _pure_order_promotes = self.order_promotes.select { |op| op.order_item_id.nil? }
-
-    self.pure_serve_sum = _pure_order_serves.sum { |o| o.amount }
-    self.pure_promote_sum = _pure_order_promotes.sum { |o| o.amount }
-    self.subtotal = self.order_items.sum { |o| o.amount }
-    self.amount = self.subtotal.to_d + self.pure_serve_sum.to_d + self.pure_promote_sum.to_d
+  def metering_attributes
+    attributes.slice 'quantity', 'amount'
   end
 
-  def promote_amount
-    order_promotes.sum(:amount)
-  end
+  def sync_from_cart
+    cart.trade_items.checked.default_where(myself: myself).update_all(trade_type: self.class.name, trade_id: self.id)
+    cart.trade_promotes.update_all(trade_type: self.class.name, trade_id: self.id)
 
-  def serve_amount
-    serve_promotes.sum(:amount)
+    self.compute_amount
+    self.save
   end
 
   def confirm_ordered!
-    self.order_items.each do |oi|
-      oi.confirm_ordered!
-    end
+    self.trade_items.each(&:confirm_ordered!)
+  end
+
+  def compute_received_amount
+    _received_amount = self.payment_orders.where(state: 'confirmed').sum(:check_amount)
+    _refund_amount = self.refunds.where.not(state: 'failed').sum(:total_amount)
+    _received_amount - _refund_amount
   end
 
-end unless RailsTrade.config.disabled_models.include?('Order')
+end

data/app/models/rails_trade/ordering/payment.rb

@@ -0,0 +1,113 @@
+# payment_id
+# payment_type
+# amount
+# received_amount
+module RailsTrade::Ordering::Payment
+
+  def can_pay?
+    self.payment_status != 'all_paid'
+  end
+
+  def unreceived_amount
+    self.amount.to_d - self.received_amount.to_d
+  end
+
+  def init_received_amount
+    self.payment_orders.confirmed.sum(:check_amount)
+  end
+
+  def pending_payments
+    Payment.where.not(id: self.payment_orders.pluck(:payment_id)).where(payment_method_id: self.buyer.payment_method_ids, state: ['init', 'part_checked'])
+  end
+
+  def exists_payments
+    Payment.where.not(id: self.payment_orders.pluck(:payment_id)).exists?(payment_method_id: self.buyer.payment_method_ids, state: ['init', 'part_checked'])
+  end
+
+  def confirm_paid!
+    self.expire_at = nil
+    self.trade_items.each(&:confirm_paid!)
+    sent_notice
+  end
+
+  def confirm_part_paid!
+    self.expire_at = nil
+    self.trade_items.each(&:confirm_part_paid!)
+  end
+
+  def change_to_paid!(type:, payment_uuid:, params: {})
+    payment = self.payments.find_by(type: type, payment_uuid: payment_uuid)
+
+    if payment
+      self.check_state!
+      payment
+    else
+      payment = self.payments.build(type: type, payment_uuid: payment_uuid)
+      payment.assign_detail params
+
+      payment_order = self.payment_orders.find { |i| i.id.nil? }
+      payment_order.check_amount = payment.total_amount
+
+      begin
+        self.class.transaction do
+          payment_order.confirm!
+          payment.save!
+          self.save!
+        end
+      rescue ActiveRecord::RecordInvalid => e
+        payment.errors.add :base, 'can not save'
+        logger.error "#{payment.errors.full_messages.join(', ')}"
+        raise e
+      end
+      payment
+    end
+  end
+
+  def sent_notice
+    return unless self.user
+    PaidChannel.broadcast_to(
+      self.user_id,
+      link: url_helpers.my_order_url(id),
+      )
+  end
+
+  def payment_result(payment_kind: payment_type)
+    if self.payment_status == 'all_paid'
+      return self
+    end
+
+    if self.amount == 0
+      self.received_amount = self.amount
+      self.check_state!
+    end
+
+    if payment_kind.present?
+      begin
+        self.send payment_kind.to_s + '_result'
+      rescue NoMethodError
+        self
+      end
+    end
+
+    self
+  end
+
+  def check_state
+    if self.received_amount.to_d >= self.amount
+      self.payment_status = 'all_paid'
+      self.confirm_paid!
+    elsif self.received_amount.to_d > 0 && self.received_amount.to_d < self.amount
+      self.payment_status = 'part_paid'
+      self.confirm_part_paid!
+    elsif self.received_amount.to_d <= 0
+      self.payment_status = 'unpaid'
+    end
+  end
+
+  def check_state!
+    self.received_amount = init_received_amount
+    self.check_state
+    self.save!
+  end
+
+end