rails_trade 0.0.1 → 0.0.2

data/app/models/rails_trade/promote_charge/cash_promote_charge.rb

@@ -0,0 +1,12 @@
+# 抵扣券，如果抵扣券金额大于总额，则为0
+module RailsTrade::PromoteCharge::CashPromoteCharge
+
+  def final_price(amount)
+    if parameter.abs >= amount
+      - amount
+    else
+      - parameter.abs
+    end
+  end
+
+end

data/app/models/rails_trade/promote_charge/discount_promote_charge.rb

@@ -0,0 +1,17 @@
+# 折扣价格
+module RailsTrade::PromoteCharge::DiscountPromoteCharge
+
+  # 用户输入参数可为
+  # 正数的折扣，原价 * 折扣， 如 100 * 0.7， parameter 为0.7
+  # 负数的折扣，原价 * （1+折扣），如 100 * (1-0.3), parameter 为 -0.3
+  def final_price(amount)
+    if parameter < 0 && parameter > -1
+      (amount * parameter).round(2)
+    elsif parameter > 0 && parameter < 1
+      -(amount * (1 - parameter)).round(2)
+    else
+      amount
+    end
+  end
+
+end

data/app/models/rails_trade/promote_charge/final_promote_charge.rb

@@ -0,0 +1,12 @@
+# 一口价
+module RailsTrade::PromoteCharge::FinalPromoteCharge
+  extend ActiveSupport::Concern
+  included do
+  end
+  
+  # 返回原价与一口价之间的差，负数。
+  def final_price(amount)
+    -(amount - parameter)
+  end
+
+end

data/app/models/rails_trade/promote_charge/minus_promote_charge.rb

@@ -0,0 +1,11 @@
+module RailsTrade::PromoteCharge::MinusPromoteCharge
+  extend ActiveSupport::Concern
+  included do
+    validates :parameter, numericality: { less_than_or_equal_to: 0 }
+  end
+  
+  def final_price(amount = nil)
+    - parameter.abs.round(2)
+  end
+
+end

data/app/models/rails_trade/promote_charge/plus_promote_charge.rb

@@ -0,0 +1,7 @@
+module RailsTrade::PromoteCharge::PlusPromoteCharge
+
+  def final_price(amount)
+    base_price + (amount * parameter).round(2)
+  end
+
+end

data/app/models/rails_trade/promote_extra.rb

@@ -0,0 +1,13 @@
+module RailsTrade::PromoteExtra
+  extend ActiveSupport::Concern
+  included do
+    attribute :extra_name, :string
+    attribute :column_name, :string
+    
+    belongs_to :promote
+    
+    validates :extra_name, uniqueness: { scope: :promote_id }
+  end
+  
+  
+end

data/app/models/rails_trade/promote_good.rb

@@ -1,9 +1,22 @@
-class PromoteGood < ApplicationRecord
-  belongs_to :good, polymorphic: true
-  belongs_to :promote
+module RailsTrade::PromoteGood
+  extend ActiveSupport::Concern
+  
+  included do
+    attribute :status, :string, default: 'available'
 
-end unless RailsTrade.config.disabled_models.include?('PromoteGood')
-
-# :order_id, :integer
-# :order_item_id :integer
+    belongs_to :promote
+    belongs_to :good, polymorphic: true, optional: true
+    has_many :promote_buyers, dependent: :delete_all
+    
+    scope :valid, -> { where(status: ['default', 'available']) }
+    
+    enum status: {
+      default: 'default',  # 默认直接添加的服务，不可取消
+      available: 'available',  # 可选
+      unavailable: 'unavailable'  # 不可选
+    }
+    
+    validates :promote_id, uniqueness: { scope: [:good_type, :good_id] }
+  end
 
+end

data/app/models/rails_trade/refund.rb

@@ -1,23 +1,34 @@
-class Refund < ApplicationRecord
-  attribute :currency, :string, default: 'USD'
-
-  belongs_to :operator, polymorphic: true, optional: true
-  belongs_to :order, inverse_of: :refunds, optional: true
-  belongs_to :payment
-
-  validates :payment_id, uniqueness: { scope: :order_id }
+module RailsTrade::Refund
+  extend ActiveSupport::Concern
+  included do
+    attribute :type, :string
+    attribute :currency, :string, default: RailsTrade.config.default_currency
+    attribute :total_amount, :decimal, precision: 10, scale: 2
+    attribute :buyer_identifier, :string
+    attribute :comment, :string, limit: 512
+    attribute :state, :string, default: 'init'
+    attribute :refunded_at, :datetime
+    attribute :reason, :string, limit: 512
+    attribute :refund_uuid, :string
+    attribute :response, :json
+
+    belongs_to :operator, polymorphic: true, optional: true
+    belongs_to :order, inverse_of: :refunds, optional: true
+    belongs_to :payment
+
+    validates :payment_id, uniqueness: { scope: :order_id }
+
+    after_initialize if: -> { new_record? } do
+      self.refund_uuid ||= UidHelper.nsec_uuid('RD')
+      self.state = :init
+    end
 
-  after_initialize if: -> { new_record? } do
-    self.refund_uuid = UidHelper.nsec_uuid('RD')
-    self.state = :init
+    enum state: {
+      init: 'init',
+      completed: 'completed',
+      failed: 'failed'
+    }
   end
-
-  enum state: [
-    :init,
-    :completed,
-    :failed
-  ]
-
   #validate :valid_total_amount
 
   # 微信是同一个批次号未退款成功可重复申请
@@ -60,4 +71,4 @@ class Refund < ApplicationRecord
     self.init? && ['all_paid', 'part_paid', 'refunding'].include?(order.payment_status)
   end
 
-end unless RailsTrade.config.disabled_models.include?('Refund')
+end

data/app/models/rails_trade/{refunds → refund}/alipay_refund.rb

@@ -1,4 +1,4 @@
-class AlipayRefund < Refund
+module RailsTrade::Refund::AlipayRefund
   
   def do_refund(params = {})
     return unless can_refund?

data/app/models/rails_trade/refund/bank_refund.rb

@@ -0,0 +1,5 @@
+module RailsTrade::Refund::BankRefund
+
+
+
+end

data/app/models/rails_trade/refund/hand_refund.rb

@@ -0,0 +1,5 @@
+module RailsTrade::Refund::HandRefund
+
+
+
+end

data/app/models/rails_trade/{refunds → refund}/paypal_refund.rb

@@ -1,4 +1,4 @@
-class PaypalRefund < Refund
+module RailsTrade::Refund::PaypalRefund
 
   def do_refund(params = {})
     return unless can_refund?

data/app/models/rails_trade/{refunds → refund}/stripe_refund.rb

@@ -1,4 +1,4 @@
-class StripeRefund < Refund
+module RailsTrade::Refund::StripeRefund
 
   def do_refund(params = {})
     return unless can_refund?

data/app/models/rails_trade/{refunds → refund}/wxpay_refund.rb

@@ -1,4 +1,4 @@
-class WxpayRefund < Refund
+module RailsTrade::Refund::WxpayRefund
 
   def transaction_id
     refunded_payment&.payment_uuid
@@ -9,7 +9,7 @@ class WxpayRefund < Refund
   end
 
   def do_refund(params = {})
-    params = {
+    _params = {
       out_refund_no: self.refund_uuid,
       total_fee: (payment.total_amount * 100).to_i,
       refund_fee: (total_amount * 100).to_i,
@@ -17,24 +17,32 @@ class WxpayRefund < Refund
     }
 
     begin
-      result = WxPay::Service.invoke_refund(params)
+      result = WxPay::Service.invoke_refund(_params)
       if result['result_code'] == 'SUCCESS'
-        self.update(state: 'completed')
+        self.state = 'completed'
+        order.payment_status = 'refunded'
+        self.refunded_at = Time.now
       else
-        self.update(state: 'failed', comment: result['result_code'])
+        self.state = 'failed'
+        self.comment = result['result_code']
       end
     rescue StandardError => e
-      result = e.message
-      self.update(state: 'failed', comment: result.truncate(225))
+      self.state = 'failed'
+      self.comment = e.message.truncate(225)
+    ensure
+      self.class.transaction do
+        self.save!
+        order.save!
+      end
     end
-    result
+    self
   end
 
   def refund_query
     params = {
       out_refund_no: self.refund_uuid
     }
-    result = WxPay::Service.refund_query(params)
+    WxPay::Service.refund_query(params)
   end
 
 end

data/app/models/rails_trade/sell.rb

@@ -0,0 +1,24 @@
+module RailsTrade::Sell
+  extend ActiveSupport::Concern
+
+  included do
+    include RailsTrade::Good
+    attribute :buyer_type, :string
+    attribute :buyer_id, :integer
+
+    belongs_to :buyer, polymorphic: true, optional: true
+
+    has_one :order_item, as: :good, dependent: :nullify
+    has_one :order, ->(o){ where(buyer_type: o.buyer.class.name, buyer_id: o.buyer.id) }, through: :order_item
+  end
+
+  def update_order
+    order_item.update amount: self.price
+  end
+
+  def get_order
+    return @get_order if defined?(@get_order)
+    @get_order = self.order || generate_order!(buyer: self.buyer, number: 1)
+  end
+
+end

data/app/models/rails_trade/trade_item.rb

@@ -0,0 +1,153 @@
+module RailsTrade::TradeItem
+  extend ActiveSupport::Concern
+  included do
+    attribute :status, :string, default: 'checked'
+    attribute :myself, :boolean, default: true, comment: '是否后台协助添加'
+    attribute :starred, :boolean, default: false, comment: '收藏'
+    attribute :good_name, :string
+    attribute :number, :integer, default: 1
+    attribute :weight, :decimal, default: 0, comment: '重量'
+    attribute :unit, :string, comment: '单位'
+    attribute :single_price, :decimal, default: 0, comment: '一份产品的价格'
+    attribute :original_amount, :decimal, default: 0, comment: '合计份数之后的价格，商品原价'
+    attribute :additional_amount, :decimal, default: 0, comment: '附加服务价格汇总'
+    attribute :reduced_amount, :decimal, default: 0, comment: '已优惠的价格'
+    attribute :retail_price, :decimal, default: 0, comment: '单个商品零售价(商品原价 + 服务价)'
+    attribute :wholesale_price, :decimal, default: 0, comment: '多个商品批发价'
+    attribute :amount, :decimal, default: 0
+    attribute :note, :string
+    attribute :advance_amount, :decimal, default: 0
+    attribute :extra, :json, default: {}
+
+    belongs_to :good, polymorphic: true
+    belongs_to :trade, polymorphic: true, inverse_of: :trade_items, counter_cache: true
+    has_many :trade_promotes, -> { includes(:promote).single }, inverse_of: :trade_item, dependent: :destroy
+    #has_many :organs, dependent: :delete_all 用于对接供应商
+
+    scope :valid, -> { where(status: 'init', myself: true) }
+    scope :starred, -> { where(status: 'init', starred: true) }
+
+    enum status: {
+      init: 'init',
+      checked: 'checked',
+      ordered: 'ordered',
+      done: 'done',
+      canceled: 'canceled'
+    }
+
+    after_initialize if: :new_record? do
+      if good
+        self.good_name = good.name
+        self.single_price = good.price
+      end
+    end
+    after_update :sync_changed_amount, if: -> { (saved_changes.keys & ['amount', 'additional_amount', 'reduced_amount']).present? }
+    after_commit :sync_cart_charges, :total_cart_charges, if: -> { number_changed? }, on: [:create, :update]
+  end
+
+  def original_quantity
+    good.unified_quantity * self.number
+  end
+
+  # 批发价和零售价之间的差价，即批发折扣
+  def discount_price
+    wholesale_price - (retail_price * number)
+  end
+
+  def init_amount
+    self.original_amount = single_price * number
+    self.advance_amount = good.advance_price
+    self.amount = original_amount
+    trade.item_amount += amount
+    trade.amount += amount
+  end
+
+  def compute_promote
+    good.valid_promote_goods.map do |promote_good|
+      value = metering_attributes.fetch(promote_good.promote.metering)
+      promote_charge = promote_good.promote.compute_charge(value, **extra)
+      next unless promote_charge
+      if promote_good.promote.single?
+        tp = self.trade_promotes.build(promote_charge_id: promote_charge.id, promote_good_id: promote_good.id)
+      else
+        tp = trade.trade_promotes.build(promote_charge_id: promote_charge.id, promote_good_id: promote_good.id)
+      end
+      tp.compute_amount
+    end
+
+    return unless trade.buyer
+    trade.buyer.promote_buyers.each do |promote_buyer|
+      value = metering_attributes.fetch(promote_buyer.promote.metering)
+      promote_charge = promote_buyer.promote.compute_charge(value, **extra)
+      next unless promote_charge
+      if promote_good.promote.single?
+        tp = self.trade_promotes.build(promote_charge_id: promote_charge.id, promote_buyer_id: promote_buyer.id, promote_good_id: promote_buyer.promote_good_id)
+      else
+        tp = trade.trade_promotes.build(promote_charge_id: promote_charge.id, promote_buyer_id: promote_buyer.id, promote_good_id: promote_buyer.promote_good_id)
+      end
+      tp.compute_amount
+    end
+  end
+
+  def sum_amount
+    self.additional_amount = trade_promotes.select(&->(o){ o.amount >= 0 }).sum(&:amount)
+    self.reduced_amount = trade_promotes.select(&->(o){ o.amount < 0 }).sum(&:amount)  # 促销价格
+
+    self.retail_price = single_price + additional_amount
+    self.wholesale_price = original_amount + additional_amount
+
+    self.amount = original_amount + additional_amount + reduced_amount  # 最终价格
+    self
+  end
+
+  def sync_changed_amount
+    self.amount = original_amount + additional_amount + reduced_amount
+
+    changed_amount = amount - amount_before_last_save
+    trade.item_amount += changed_amount
+    trade.amount += changed_amount
+    if trade.amount == trade.compute_saved_amount
+      trade.save!
+    else
+      trade.errors.add :amount, 'not equal'
+      logger.error "#{self.class.name}/#{trade.class.name}: #{trade.error_text}"
+      raise ActiveRecord::RecordInvalid.new(trade)
+    end
+  end
+
+  def reset_amount
+    self.additional_amount = trade_promotes.default_where('amount-gte': 0).sum(:amount)
+    self.reduced_amount = trade_promotes.default_where('amount-lt': 0).sum(:amount)
+    self.amount = original_amount + additional_amount + reduced_amount
+    self.valid?
+    self.changes
+  end
+
+  def reset_amount!
+    self.reset_amount
+    self.update_columns changes.transform_values(&->(o){ o[1] })
+  end
+
+  def valid_promote_buyers(buyer)
+    ids = (available_promote_ids & buyer.all_promote_ids) - buyer.promote_buyers.pluck(:promote_id)
+    Promote.where(id: ids)
+  end
+
+  def metering_attributes
+    attributes.slice 'quantity', 'amount', 'number'
+  end
+
+  def confirm_ordered!
+    self.good.order_done
+  end
+
+  def confirm_paid!
+  end
+
+  def confirm_part_paid!
+  end
+
+  def confirm_refund!
+  end
+
+end

data/app/models/rails_trade/trade_promote.rb

@@ -0,0 +1,92 @@
+module RailsTrade::TradePromote
+  extend ActiveSupport::Concern
+  included do
+    attribute :sequence, :integer
+    attribute :scope, :string
+    attribute :original_amount, :decimal, comment: '初始价格'
+    attribute :based_amount, :decimal, precision: 10, scale: 2, default: 0, comment: '基于此价格计算，默认为 trade_item 的 amount，与sequence有关'
+    attribute :computed_amount, :decimal, precision: 10, scale: 2, default: 0, comment: '计算出的价格'
+    attribute :amount, :decimal, precision: 10, scale: 2, default: 0, comment: '默认等于 computed_amount，如果客服人员修改过价格后，则 amount 会发生变化'
+    attribute :note, :string, comment: '备注'
+    
+    belongs_to :trade, polymorphic: true, inverse_of: :trade_promotes
+    belongs_to :trade_item, optional: true
+    belongs_to :promote
+    belongs_to :promote_charge
+    belongs_to :promote_good
+    belongs_to :promote_buyer, counter_cache: true, optional: true
+    
+    validates :promote_id, uniqueness: { scope: [:trade_type, :trade_id, :trade_item_id] }
+    validates :amount, presence: true
+    
+    enum scope: {
+      single: 'single',
+      overall: 'overall'
+    }
+
+    after_initialize if: :new_record? do
+      if trade_item
+        self.trade = trade_item.trade
+      end
+      if self.promote_good
+        self.promote_id = self.promote_good.promote_id
+        self.sequence = self.promote.sequence
+        self.scope = self.promote.scope
+      end
+    end
+    after_update :sync_changed_amount, if: -> { saved_change_to_amount? }
+    after_create_commit :check_promote_buyer
+  end
+
+  def compute_amount
+    if single?
+      value = trade_item.metering_attributes.fetch(promote.metering, 0)
+      added_amount = trade_item.trade_promotes.select { |cp| cp.promote.sequence < self.promote.sequence }.sum(&->(o){ o.send(promote.metering) })
+      
+      self.based_amount = value + added_amount
+    else
+      value = trade.metering_attributes.fetch(promote.metering, 0)
+      added_amount = trade.trade_promotes.select { |cp| cp.promote.sequence < self.promote.sequence }.sum(&->(o){ o.send(promote.metering) })
+      
+      self.based_amount = value + added_amount
+    end
+
+    self.computed_amount = self.promote_charge.final_price(based_amount)
+    self.amount = computed_amount if amount.zero?
+    self
+  end
+  
+  def sync_changed_amount
+    if amount >= 0 && amount_before_last_save >= 0
+      _additional_amount = amount - amount_before_last_save
+      _reduced_amount = 0
+    elsif amount >= 0 && amount_before_last_save < 0
+      _additional_amount = amount
+      _reduced_amount = -amount_before_last_save
+    elsif amount < 0 && amount_before_last_save >= 0
+      _additional_amount = -amount_before_last_save
+      _reduced_amount = amount
+    else  # amount < 0 && amount_before_last_save < 0
+      _additional_amount = 0
+      _reduced_amount = amount - amount_before_last_save
+    end
+    
+    if overall?
+      trade.overall_additional_amount += _additional_amount
+      trade.overall_reduced_amount += _reduced_amount
+      trade.amount += (_additional_amount + _reduced_amount)
+      trade.save!
+    elsif single?
+      trade_item.additional_amount += _additional_amount
+      trade_item.reduced_amount += _reduced_amount
+      trade_item.amount += (_additional_amount + _reduced_amount)
+      trade_item.save!
+    end
+  end
+
+  def check_promote_buyer
+    return unless promote_buyer
+    self.promote_buyer.update state: 'used'
+  end
+  
+end