rails_trade 0.0.2 → 0.0.3

data/app/models/trade/model/refund.rb

@@ -0,0 +1,70 @@
+module Trade
+  module Model::Refund
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :type, :string
+      attribute :currency, :string, default: RailsTrade.config.default_currency
+      attribute :total_amount, :decimal
+      attribute :buyer_identifier, :string
+      attribute :comment, :string
+      attribute :refunded_at, :datetime
+      attribute :reason, :string
+      attribute :refund_uuid, :string
+      attribute :response, :json
+
+      enum state: {
+        init: 'init',
+        completed: 'completed',
+        failed: 'failed',
+        denied: 'denied'
+      }, _default: 'init'
+
+      belongs_to :organ, class_name: 'Org::Organ', optional: true
+      belongs_to :operator, class_name: 'Org::Member', optional: true
+      belongs_to :order, inverse_of: :refunds, optional: true
+      belongs_to :payment
+
+      validates :payment_id, uniqueness: { scope: :order_id }
+      #validate :valid_total_amount
+
+      before_validation do
+        self.refund_uuid ||= UidHelper.nsec_uuid('RD') if new_record?
+        self.organ_id = payment.organ_id
+      end
+      after_save :sync_refund, if: -> { completed? && state_before_last_save == 'init' }
+      after_save :deny_refund, if: -> { denied? && state_before_last_save == 'init' }
+    end
+
+    def valid_total_amount
+      if self.new_record? && total_amount > payment.total_amount
+        self.errors.add :total_amount, 'more then order received amount!'
+      end
+    end
+
+    def currency_symbol
+      Money::Currency.new(self.currency).symbol
+    end
+
+    def sync_refund
+      payment.total_amount -= total_amount
+      payment.refunded_amount = total_amount
+      payment.save
+
+      if order
+        order.payment_status = 'refunded'
+        order.save
+      end
+    end
+
+    def deny_refund
+      order.payment_status = 'denied'
+      order.save
+    end
+
+    def can_refund?
+      self.init? && ['all_paid', 'part_paid', 'refunding'].include?(order.payment_status)
+    end
+
+  end
+end

data/app/models/trade/model/sell.rb

@@ -0,0 +1,24 @@
+module Trade
+  module Model::Sell
+    extend ActiveSupport::Concern
+
+    included do
+      include Model::Good
+
+      belongs_to :buyer, optional: true
+
+      has_one :trade_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
+end

data/app/models/trade/model/trade_item.rb

@@ -0,0 +1,214 @@
+module Trade
+  module Model::TradeItem
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :status, :string
+      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 :retail_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 :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 :user, class_name: 'Auth::User'
+      belongs_to :good, polymorphic: true
+      belongs_to :cart, counter_cache: true
+      belongs_to :order, inverse_of: :trade_items, counter_cache: true, optional: true
+      belongs_to :address, optional: true
+      belongs_to :produce_plan, optional: true  # 产品对应批次号
+      has_many :trade_promotes, inverse_of: :trade_item, autosave: true, dependent: :destroy
+      #has_many :organs 用于对接供应商
+
+      scope :valid, -> { where(status: 'init', myself: true) }
+      scope :starred, -> { where(status: 'init', starred: true) }
+      default_scope -> { order(id: :asc) }
+
+      enum status: {
+        init: 'init',
+        checked: 'checked',
+        ordered: 'ordered',
+        paid: 'paid',
+        packaged: 'packaged',
+        done: 'done',
+        canceled: 'canceled'
+      }, _default: 'init'
+
+      after_initialize if: :new_record? do
+        if good
+          self.good_name = good.name
+          self.single_price = good.price
+          self.advance_amount = good.advance_price
+          self.produce_plan_id = good.product_plan&.produce_plan_id if good.respond_to? :product_plan_id
+        end
+        if cart
+          self.user_id = cart.user_id
+          self.member_id = cart.member_id if cart.respond_to?(:member_id) && respond_to?(:member_id)
+        end
+        self.original_amount = single_price * number
+        self.amount = original_amount
+      end
+      before_save :recompute_amount, if: -> { (changes.keys & ['number']).present? }
+      before_save :compute_promote, if: -> { original_amount_changed? }
+      after_save :sync_changed_amount, if: -> {
+        (saved_changes.keys & ['original_amount', 'additional_amount', 'reduced_amount', 'status']).present? && ['init', 'checked'].include?(status)
+      }
+      after_destroy_commit :sync_changed_amount
+      after_commit :sync_cart_charges, if: -> { number_changed? }, on: [:create, :update]
+    end
+
+    def weight_str
+      if weight > 0
+        "#{weight} #{unit}"
+      end
+    end
+
+    def original_quantity
+      good.unified_quantity * self.number
+    end
+
+    # 批发价和零售价之间的差价，即批发折扣
+    def discount_price
+      wholesale_price - (retail_price * number)
+    end
+
+    def recompute_amount
+      self.original_amount = single_price * number
+      self.amount = original_amount + additional_amount + reduced_amount
+    end
+
+    def check
+      self.status = 'checked'
+      self.save
+      self
+    end
+
+    def uncheck
+      self.status = 'init'
+      self.save
+      self
+    end
+
+    # todo remove
+    def sync_from_cart
+      cart.trade_items.checked.default_where(myself: myself).update_all(trade_type: self.class.name, trade_id: self.id, address_id: self.address_id)
+      cart.trade_promotes.update_all(trade_type: self.class.name, trade_id: self.id)
+
+      self.compute_amount
+      self.save
+    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.find(&->(i){ i.promote_good_id == promote_good.id }) || trade_promotes.build(promote_good_id: promote_good.id)
+        else
+          tp = order.trade_promotes.find(&->(i){ i.promote_good_id == promote_good.id }) || order.trade_promotes.build(promote_good_id: promote_good.id)
+        end
+        tp.promote_charge_id = promote_charge.id
+        tp.compute_amount
+      end
+
+      cart.promote_carts.each do |promote_cart|
+        value = metering_attributes.fetch(promote_cart.promote.metering)
+        promote_charge = promote_cart.promote.compute_charge(value, **extra)
+        next unless promote_charge
+        if promote_good.promote.single?
+          tp = self.trade_promotes.find_or_initialize_by(promote_cart_id: promote_cart.id, promote_good_id: promote_cart.promote_good_id)
+        else
+          tp = trade.trade_promotes.find_or_initialize_by(promote_cart_id: promote_cart.id, promote_good_id: promote_cart.promote_good_id)
+        end
+        tp.promote_charge_id = promote_charge.id
+        tp.compute_amount
+      end
+
+      sum_amount
+    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.changes
+    end
+
+    def sync_changed_amount
+      if destroyed? || (init? && status_before_last_save == 'checked')
+        changed_amount = -amount
+      elsif checked? && ['init', nil].include?(status_before_last_save)
+        changed_amount = amount
+      elsif checked? && saved_change_to_amount
+        changed_amount = amount - amount_before_last_save.to_d
+      else
+        return
+      end
+
+      if ['init', 'checked'].include?(status)
+        cart.reload
+        cart.item_amount += changed_amount
+        cart.valid_item_amount
+        cart.save!
+      else
+        order.reload
+        order.item_amount += changed_amount
+        order.valid_item_amount
+        order.save!
+      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!(*args)
+      self.reset_amount
+      self.save(*args)
+    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', 'original_amount', 'number'
+    end
+
+    def confirm_ordered!
+      self.good.order_done
+    end
+
+    def confirm_paid!
+      self.update status: 'paid'
+      self.good.order_paid(self)
+    end
+
+    def confirm_part_paid!
+    end
+
+    def confirm_refund!
+    end
+
+  end
+end

data/app/models/trade/model/trade_promote.rb

@@ -0,0 +1,69 @@
+module Trade
+  module Model::TradePromote
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :sequence, :integer
+      attribute :original_amount, :decimal, comment: '初始价格'
+      attribute :based_amount, :decimal, default: 0, comment: '基于此价格计算，默认为 trade_item 的 amount，与sequence有关'
+      attribute :computed_amount, :decimal, default: 0, comment: '计算出的价格'
+      attribute :amount, :decimal, default: 0, comment: '默认等于 computed_amount，如果客服人员修改过价格后，则 amount 会发生变化'
+      attribute :note, :string, comment: '备注'
+      attribute :edited, :boolean, default: false, comment: '是否被客服改过价'
+      attribute :promote_name, :string
+
+      belongs_to :cart
+      belongs_to :order, inverse_of: :trade_promotes, optional: true
+      belongs_to :trade_item, optional: true
+      belongs_to :promote
+      belongs_to :promote_charge
+      belongs_to :promote_good
+      belongs_to :promote_cart, counter_cache: true, optional: true
+
+      enum status: {
+        init: 'init',
+        checked: 'checked',
+        ordered: 'ordered'
+      }, _default: 'init'
+
+      validates :promote_id, uniqueness: { scope: [:cart_id, :trade_item_id] }
+      validates :amount, presence: true
+
+      after_initialize if: :new_record? do
+        if trade_item
+          self.cart = trade_item.cart
+          self.order = trade_item.order
+        end
+        if self.promote_good
+          self.promote_id = self.promote_good.promote_id
+        end
+        self.sequence = self.promote.sequence
+      end
+      after_create_commit :check_promote_cart
+    end
+
+    def compute_amount
+      if trade_item
+        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 unless edited?
+      self
+    end
+
+    def check_promote_cart
+      return unless promote_cart
+      self.promote_cart.update state: 'used'
+    end
+
+  end
+end

data/app/models/trade/order.rb

@@ -0,0 +1,8 @@
+module Trade
+  class Order < ApplicationRecord
+    include Model::Order
+    include Model::Amount
+    include Ordering::Payment
+    include Ordering::Refund
+  end
+end

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

@@ -0,0 +1,112 @@
+# payment_id
+# payment_type
+# amount
+# received_amount
+module Trade
+  module 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.cart.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.cart.payment_method_ids, state: ['init', 'part_checked'])
+    end
+
+    def confirm_paid!
+      self.expire_at = nil
+      self.trade_items.each(&:confirm_paid!)
+      send_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.organ_id = organ_id
+        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 send_notice
+      broadcast_action_to self, action: :update, target: 'order_result', partial: 'trade/my/orders/success'
+    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
+end