rails_trade 0.0.2 → 0.0.3

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

@@ -0,0 +1,66 @@
+module Trade
+  module Model::Good
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :name, :string
+      attribute :sku, :string, default: -> { SecureRandom.hex }
+      attribute :price, :decimal, precision: 10, scale: 2, 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: :good, autosave: true, dependent: :destroy
+      has_many :orders, through: :trade_items, source: :trade
+      has_many :addresses, -> { distinct }, through: :trade_items
+
+      has_many :promote_goods, class_name: 'Trade::PromoteGood', as: :good
+    end
+
+    def final_price
+      compute_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!(cart: , maintain_id: nil, **params)
+      o = generate_order(cart: cart, maintain_id: maintain_id, **params)
+      o.check_state
+      o.save!
+      o
+    end
+
+    def generate_order(cart: , maintain_id: nil, **params)
+      o = cart.orders.build
+
+      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)
+
+      o.assign_attributes params.slice(:extra, :currency)
+      o
+    end
+
+    def order_done(trade_item = nil)
+      puts 'Should realize in good entity'
+    end
+
+    def order_paid(trade_item = nil)
+    end
+
+  end
+end

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

@@ -0,0 +1,25 @@
+module Trade
+  module Model::Member
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :payment_references, dependent: :destroy, autosave: true
+      has_many :payment_methods, through: :payment_references, autosave: true
+
+      scope :credited, -> { where(payment_strategy_id: self.credit_ids) }
+    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
+end

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

@@ -0,0 +1,127 @@
+module Trade
+  module Model::Order
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :uuid, :string
+      attribute :state, :string
+      attribute :received_amount, :decimal, default: 0
+      attribute :payment_id, :integer, comment: 'for paypal'
+      attribute :myself, :boolean, default: true
+      attribute :note, :string
+      attribute :expire_at, :datetime
+      attribute :payment_status, :string, default: 'unpaid', index: true
+      attribute :expire_at, :datetime, default: -> { Time.current + RailsTrade.config.expire_after }
+      attribute :extra, :json, default: {}
+      attribute :currency, :string, default: RailsTrade.config.default_currency
+
+      belongs_to :organ, class_name: 'Org::Organ', optional: true
+      belongs_to :user, class_name: 'Auth::User'
+      belongs_to :address, class_name: 'Profiled::Address', optional: true
+      belongs_to :produce_plan, class_name: 'Factory::ProducePlan', optional: true  # 统一批次号
+
+      belongs_to :cart
+      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
+      has_many :promote_carts, -> { valid }, foreign_key: :cart_id, primary_key: :cart_id, dependent: :destroy
+      has_many :promotes, through: :promote_carts
+      has_many :trade_items, dependent: :destroy
+      has_many :trade_promotes, -> { where(trade_item_id: nil) }, dependent: :destroy  # overall can be blank
+      accepts_nested_attributes_for :trade_items
+      accepts_nested_attributes_for :trade_promotes
+
+      scope :credited, -> { where(payment_strategy_id: PaymentStrategy.where.not(period: 0).pluck(:id)) }
+      scope :to_pay, -> { where(payment_status: ['unpaid', 'part_paid']) }
+
+      enum state: {
+        init: 'init',
+        checked: 'checked'
+      }, _default: 'init'
+
+      enum payment_status: {
+        unpaid: 'unpaid',
+        to_check: 'to_check',
+        part_paid: 'part_paid',
+        all_paid: 'all_paid',
+        refunding: 'refunding',
+        refunded: 'refunded',
+        denied: 'denied'
+      }, _default: 'unpaid'
+
+      after_initialize if: :new_record? do
+        if cart
+          self.user_id = cart.user_id
+          self.organ_id = cart.organ_id if cart.respond_to?(:organ_id) && self.respond_to?(:organ_id)
+          self.address_id = cart.address_id
+          self.payment_strategy_id = cart.payment_strategy_id
+        end
+      end
+      before_validation do
+        self.uuid ||= UidHelper.nsec_uuid('OD')
+      end
+      after_create :sync_from_cart
+      after_create_commit :confirm_ordered!
+
+      delegate :url_helpers, to: 'Rails.application.routes'
+    end
+
+    def remaining_amount
+      amount - received_amount
+    end
+
+    def subject
+      r = trade_items.map { |oi| oi.good.name.presence }.join(', ')
+      r.presence || 'goods'
+    end
+
+    def sync_from_cart
+      cart.trade_items.checked.default_where(myself: myself).update_all(order_id: self.id, address_id: self.address_id, status: 'ordered')
+      cart.trade_promotes.update_all(order_id: self.id, status: 'ordered')
+
+      self.compute_amount
+      cart.compute_amount
+
+      cart.save
+      self.save
+    end
+
+    def user_name
+      user.name.presence || "#{user_id}"
+    end
+
+    def amount_money
+      amount_to_money(self.currency)
+    end
+
+    def compute_amount
+      self.item_amount = trade_items.sum(:amount)
+      self.overall_additional_amount = trade_promotes.default_where('amount-gte': 0).sum(:amount)
+      self.overall_reduced_amount = trade_promotes.default_where('amount-lt': 0).sum(:amount)
+      self.amount = item_amount + overall_additional_amount + overall_reduced_amount
+    end
+
+    def valid_item_amount
+      summed_amount = trade_items.sum(:amount)
+
+      unless item_amount == summed_amount
+        errors.add :item_amount, "Item Amount #{item_amount} not equal #{summed_amount}"
+        logger.error "#{self.class.name}: #{error_text}"
+        raise ActiveRecord::RecordInvalid.new(self)
+      end
+    end
+
+    def confirm_ordered!
+      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
+end

data/app/models/trade/model/payment/alipay_payment.rb

@@ -0,0 +1,17 @@
+module Trade
+  module Model::Payment::AlipayPayment
+
+    def assign_detail(params)
+      self.buyer_identifier = params['buyer_login_id']
+      self.pay_status = params['trade_status']
+
+      self.total_amount = params['total_amount']
+      self.income_amount = params['receipt_amount']
+
+      self.notified_at = params['send_pay_date']
+
+      self.seller_identifier = params['store_id'].to_s + params['terminal_id'].to_s
+    end
+
+  end
+end

data/app/models/trade/model/payment/apple_payment.rb

@@ -0,0 +1,9 @@
+module Trade
+  module Model::Payment::ApplePayment
+
+    def assign_detail(params)
+      self.total_amount = params[:total_amount]
+    end
+
+  end
+end

data/app/models/trade/model/payment/bank_payment.rb

@@ -0,0 +1,19 @@
+module Trade
+  module Model::Payment::BankPayment
+    extend ActiveSupport::Concern
+
+    included do
+      validates :buyer_name, presence: true
+      validates :buyer_identifier, presence: true
+    end
+
+    def assign_detail(params)
+      self.notified_at = Time.current
+      self.total_amount = params[:total_amount]
+      self.order_uuid = order.uuid
+      self.buyer_email = order.contact&.email
+      self.buyer_identifier = order.contact_id
+    end
+
+  end
+end

data/app/models/trade/model/payment/card_payment.rb

@@ -0,0 +1,72 @@
+module Trade
+  module Model::Payment::CardPayment
+    extend ActiveSupport::Concern
+
+    included do
+      belongs_to :card
+      has_many :card_logs, ->(o){ where(card_id: o.card_id) }, as: :source
+
+      before_validation :init_amount, if: -> { checked_amount_changed? }
+      after_update :sync_amount, if: -> { saved_change_to_total_amount? }
+      after_create_commit :sync_card_log, if: -> { saved_change_to_total_amount? }
+      after_destroy :sync_amount_after_destroy
+      after_destroy_commit :sync_destroy_card_log
+    end
+
+    def init_amount
+      self.total_amount = checked_amount if total_amount.zero?
+    end
+
+    def assign_detail(params)
+      self.notified_at = Time.current
+      self.total_amount = params[:total_amount]
+    end
+
+    def compute_amount
+      self.income_amount = 0
+    end
+
+    def sync_amount
+      card.reload
+      card.expense_amount += self.total_amount
+      computed = card.compute_expense_amount
+      if card.expense_amount == computed
+        card.save!
+      else
+        card.errors.add :expense_amount, "#{card.expense_amount} Not Equal Computed #{computed}"
+        logger.error "#{self.class.name}/Card: #{card.error_text}"
+        raise ActiveRecord::RecordInvalid.new(card)
+      end
+    end
+
+    def sync_amount_after_destroy
+      card.reload
+      card.expense_amount -= self.total_amount
+      computed = card.compute_expense_amount
+      if card.expense_amount == computed
+        card.save!
+      else
+        card.errors.add :expense_amount, "#{card.expense_amount} Not Equal Computed #{computed}"
+        logger.error "#{self.class.name}/Card: #{card.error_text}"
+        raise ActiveRecord::RecordInvalid.new(card)
+      end
+    end
+
+    def sync_card_log
+      cl = self.card_logs.build
+      cl.title = payment_uuid
+      cl.tag_str = '支出'
+      cl.amount = -self.total_amount
+      cl.save
+    end
+
+    def sync_destroy_card_log
+      cl = self.card_logs.build
+      cl.title = payment_uuid
+      cl.tag_str = '退款'
+      cl.amount = self.total_amount
+      cl.save
+    end
+
+  end
+end

data/app/models/trade/model/payment/hand_payment.rb

@@ -0,0 +1,10 @@
+module Trade
+  module Model::Payment::HandPayment
+
+    def assign_detail(params)
+      self.notified_at = Time.current
+      self.total_amount = params[:total_amount]
+    end
+
+  end
+end

data/app/models/trade/model/payment/paypal_payment.rb

@@ -0,0 +1,10 @@
+module Trade
+  module Model::Payment::PaypalPayment
+
+    def assign_detail(trans)
+      self.payment_uuid = trans.related_resources[0].sale.id
+      self.total_amount = trans.amount.total
+    end
+
+  end
+end

data/app/models/trade/model/payment/stripe_payment.rb

@@ -0,0 +1,11 @@
+module Trade
+  module Model::Payment::StripePayment
+
+    def assign_detail(charge)
+      self.payment_uuid = charge.id
+      self.total_amount = Money.new(charge.amount, self.currency).to_d
+      self.currency = charge.currency.upcase
+    end
+
+  end
+end

data/app/models/trade/model/payment/wxpay_payment.rb

@@ -0,0 +1,15 @@
+module Trade
+  module Model::Payment::WxpayPayment
+
+    def assign_detail(params)
+      self.notified_at = params['success_time']
+      self.pay_status = params['trade_state']
+      self.seller_identifier = params['mchid']
+      self.buyer_identifier = params.dig('payer', 'openid')
+      self.buyer_bank = params['bank_type']
+      self.total_amount = params.dig('amount', 'total').to_i / 100.0
+      self.fee_amount = (self.total_amount * 0.60 / 100).round(2)
+    end
+
+  end
+end

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

@@ -0,0 +1,131 @@
+module Trade
+  module Model::Payment
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :type, :string, default: 'Trade::HandPayment'
+      attribute :payment_uuid, :string
+      attribute :state, :string, default: 'init', index: true
+      attribute :pay_status, :string
+      attribute :currency, :string, default: RailsTrade.config.default_currency
+      attribute :total_amount, :decimal, default: 0
+      attribute :checked_amount, :decimal, default: 0
+      attribute :adjust_amount, :decimal, default: 0
+      attribute :fee_amount, :decimal, default: 0
+      attribute :refunded_amount, :decimal, default: 0
+      attribute :income_amount, :decimal, comment: '实际到账'
+      attribute :notify_type, :string
+      attribute :notified_at, :datetime
+      attribute :seller_identifier, :string
+      attribute :buyer_identifier, :string
+      attribute :buyer_name, :string
+      attribute :buyer_bank, :string
+      attribute :comment, :string
+      attribute :verified, :boolean, default: true
+      attribute :lock_version, :integer
+
+      enum state: {
+        init: 'init',
+        part_checked: 'part_checked',
+        all_checked: 'all_checked',
+        adjust_checked: 'adjust_checked',
+        abusive_checked: 'abusive_checked',
+        refunded: 'refunded'
+      }, _default: 'init'
+
+      belongs_to :organ, optional: true
+      belongs_to :user, optional: true
+      belongs_to :payment_method, optional: true
+      has_many :payment_orders, inverse_of: :payment, dependent: :destroy
+      has_many :orders, through: :payment_orders, inverse_of: :payments
+      accepts_nested_attributes_for :payment_orders
+
+      default_scope -> { order(created_at: :desc) }
+
+      validates :payment_uuid, presence: true, uniqueness: { scope: :type }
+
+      before_validation do
+        self.payment_uuid = UidHelper.nsec_uuid('PAY') if payment_uuid.blank?
+      end
+      before_save :compute_amount, if: -> { (changes.keys & ['total_amount', 'fee_amount']).present? }
+      before_create :analyze_payment_method
+
+      has_one_attached :proof
+    end
+
+    def analyze_payment_method
+      if self.buyer_name.present? || self.buyer_identifier.present?
+        pm = PaymentMethod.find_or_initialize_by(account_name: self.buyer_name.to_s, account_num: self.buyer_identifier.to_s)
+        pm.bank = self.buyer_bank
+        self.payment_method = pm
+
+        pm.save
+      end
+    end
+
+    def unchecked_amount
+      total_amount.to_d - payment_orders.sum(:check_amount)
+    end
+
+    def compute_amount
+      self.income_amount = self.total_amount - self.fee_amount
+      self.check_state
+    end
+
+    def compute_checked_amount
+      self.payment_orders.where(state: :confirmed).sum(:check_amount)
+    end
+
+    def pending_orders
+      if self.payment_method
+        user_ids = self.payment_method.payment_references.pluck(:user_id)
+        Order.where.not(id: self.payment_orders.pluck(:order_id)).where(user_id: user_ids, payment_status: ['unpaid', 'part_paid'], state: 'active')
+      else
+        Order.none
+      end
+    end
+
+    def analyze_adjust_amount
+      self.adjust_amount = self.checked_amount - self.total_amount
+      self.state = 'all_checked'
+      self.save
+    end
+
+    def check_order(order_id)
+      order = Order.find order_id
+      payment_order = self.payment_orders.build(order_id: order.id)
+      payment_order.check_amount = order.unreceived_amount
+      payment_order.save
+
+      payment_order
+    end
+
+    def check_state
+      if self.checked_amount == self.total_amount
+        self.state = 'all_checked'
+      elsif self.checked_amount == 0
+        self.state = 'init'
+      elsif self.checked_amount < self.total_amount
+        self.state = 'part_checked'
+      elsif self.checked_amount > self.total_amount
+        self.state = 'adjust_checked'
+      else
+        self.state = 'abusive_checked'
+      end
+    end
+
+    def check_state!
+      self.check_state
+      self.save!
+    end
+
+    class_methods do
+
+      def total_amount_step
+        0.1.to_d.power(self.columns_hash['total_amount'].scale || self.columns_hash['total_amount'].limit)
+      end
+
+    end
+
+  end
+end