rails_trade 0.0.2 → 0.0.3

data/app/models/trade/model/payment_method/stripe_method.rb

@@ -0,0 +1,59 @@
+module Trade
+  module Model::PaymentMethod::StripeMethod
+    extend ActiveSupport::Concern
+    included do
+      attr_accessor :token
+      after_destroy_commit :remove
+    end
+
+    def retrieve
+      customer = Stripe::Customer.retrieve account_num
+      customer_info(customer)
+    end
+
+    def customer_info(customer)
+      card = customer.sources.data[0]
+      return {} unless card
+      {
+        description: customer.description,
+        address_zip: card.address_zip,
+        address_zip_check: card.address_zip_check,
+        brand: card.brand,
+        country: card.country,
+        cvc_check: card.cvc_check,
+        exp_month: card.exp_month,
+        exp_year: card.exp_year,
+        fingerprint: card.fingerprint,
+        funding: card.funding,
+        last4: card.last4
+      }
+    end
+
+    def update_extra
+      self.update extra: retrieve.to_h
+    end
+
+    def remove
+      cu = Stripe::Customer.retrieve account_num
+      cu.delete
+    end
+
+    def detective_save
+      begin
+        customer = Stripe::Customer.create(description: "buyer_id: #{payment_references.map { |i| i.buyer_id }}", source: self.token)
+        self.account_num = customer.id
+        self.extra = self.customer_info(customer)
+      rescue Stripe::StripeError => ex
+        self.errors.add :base, ex.message
+      end
+
+      self.verified = true
+      if self.errors.blank?
+        self.save
+      else
+        false
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,67 @@
+module Trade
+  module Model::PaymentMethod
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :type, :string
+      attribute :account_name, :string
+      attribute :account_num, :string
+      attribute :bank, :string
+      attribute :verified, :boolean, default: false
+      attribute :myself, :boolean, default: true
+      attribute :extra, :json, default: {}
+
+      belongs_to :creator, optional: true
+      has_many :payments, dependent: :nullify
+      has_many :payment_references, dependent: :destroy, autosave: true, inverse_of: :payment_method
+      has_many :buyers, through: :payment_references
+
+      default_scope -> { where(verified: true) }
+
+      validates :account_num, uniqueness: { scope: [:account_name, :verified] }, if: :verified?
+    end
+
+    def account_types
+      PaymentReference.pluck(:account_type).uniq
+    end
+
+    def detective_save
+      if detect_repetition
+        self.verified = false
+      else
+        self.verified = true
+      end
+      self.save
+    end
+
+    def detect_repetition
+      if self.persisted?
+        self.class.unscoped.where.not(id: self.id).exists?(account_name: self.account_name, account_num: self.account_num)
+      else
+        self.class.unscoped.exists?(account_name: self.account_name, account_num: self.account_num)
+      end
+    end
+
+    def repeat_results
+      self.class.where.not(id: self.id).where(account_name: self.account_name, account_num: self.account_num)
+    end
+
+    def merge_from(other_id)
+      other = self.class.unscoped.find other_id
+
+      self.class.transaction do
+        other.payment_references.each do |payment_reference|
+          payment_reference.payment_method_id = self.id  # for callback, do not use update
+          payment_reference.save
+        end
+        other.payment_references.reload
+        other.destroy
+      end
+    end
+
+    def kind
+      type.to_s.sub('Method', '').downcase
+    end
+
+  end
+end

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

@@ -0,0 +1,108 @@
+module Trade
+  module Model::PaymentOrder
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :check_amount, :decimal, default: 0
+
+      enum state: {
+        init: 'init',
+        confirmed: 'confirmed'
+      }, _default: 'init'
+
+      belongs_to :order, inverse_of: :payment_orders
+      belongs_to :payment, inverse_of: :payment_orders
+      has_one :refund, ->(o){ where(order_id: o.order_id) }, foreign_key: :payment_id, primary_key: :payment_id
+
+      #validate :valid_check_amount
+      validates :order_id, uniqueness: { scope: :payment_id }
+
+      after_save :checked_payment, if: -> { confirmed? && (saved_change_to_state? || saved_change_to_check_amount?) }
+      after_save :unchecked_payment, if: -> { init? && (state_before_last_save == 'confirmed' || saved_change_to_check_amount?) }
+      after_destroy_commit :unchecked_to_order
+    end
+
+    def valid_check_amount
+      if the_payment_amount > payment.total_amount + payment.adjust_amount
+        self.errors.add(:check_amount, 'Total checked amount greater than payment\'s amount')
+      end
+
+      if the_order_amount > order.amount + order.adjust_amount
+        self.errors.add(:check_amount, 'Total checked amount greater than Order\'s amount')
+      end
+    end
+
+    def checked_payment
+      checked_to_payment
+      checked_to_order
+    end
+
+    def checked_to_payment
+      payment.checked_amount += self.check_amount
+      if payment.checked_amount == payment.compute_checked_amount
+        payment.check_state
+        payment.save!
+      else
+        payment.errors.add :checked_amount, 'check not equal'
+        logger.error "#{self.class.name}/Payment: #{payment.error_text}"
+        raise ActiveRecord::RecordInvalid.new(payment)
+      end
+    end
+
+    def checked_to_order
+      order.received_amount += self.check_amount
+      if order.received_amount == order.compute_received_amount
+        order.check_state
+        order.save!
+      else
+        order.errors.add :received_amount, 'check not equal'
+        logger.error "#{self.class.name}/Order: #{order.error_text}"
+        raise ActiveRecord::RecordInvalid.new(order)
+      end
+    end
+
+    def unchecked_payment
+      unchecked_to_payment
+      unchecked_to_order
+    end
+
+    def unchecked_to_payment
+      self.payment && payment.reload
+
+      payment.checked_amount -= self.check_amount
+      if payment.checked_amount == payment.compute_checked_amount
+        payment.check_state
+        payment.save!
+      else
+        payment.errors.add :checked_amount, 'uncheck not equal'
+        logger.error "#{self.class.name}/Payment: #{payment.errors.full_messages.join(', ')}"
+        raise ActiveRecord::RecordInvalid.new(payment)
+      end
+    end
+
+    def unchecked_to_order
+      self.order && order.reload
+
+      order.received_amount -= self.check_amount
+      if order.received_amount == order.compute_received_amount
+        order.check_state
+        order.save!
+      else
+        order.errors.add :received_amount, 'uncheck not equal'
+        logger.error "#{self.class.name}/Order: #{order.errors.full_messages.join(', ')}"
+        raise ActiveRecord::RecordInvalid.new(order)
+      end
+    end
+
+    def confirm!
+      self.state = 'confirmed'
+      self.save!
+    end
+
+    def revert_confirm!
+      self.state = 'init'
+      self.save!
+    end
+
+  end
+end

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

@@ -0,0 +1,21 @@
+module Trade
+  module Model::PaymentReference
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :state, :string
+
+      belongs_to :payment_method, inverse_of: :payment_references
+      belongs_to :cart
+
+      before_save :prevent_duplicate
+    end
+
+    def prevent_duplicate
+      if PaymentReference.exists?(payment_method_id: self.payment_method_id, cart_id: self.cart_id)
+        throw(:abort)
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,22 @@
+module Trade
+  module Model::PaymentStrategy
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :name, :string
+      attribute :period, :integer, default: 0, comment: '可延期时间，单位天'
+      attribute :strategy, :string
+
+      enum strategy: {
+        # 预付全款
+        # 预付定金
+        # 后付
+      }
+    end
+
+    def credit?
+      self.period.to_i > 0
+    end
+
+  end
+end

data/app/models/trade/model/payout/wxpay_payout.rb

@@ -0,0 +1,31 @@
+module Trade
+  module Model::Payout::WxpayPayout
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :payout_uuid, :string, default: -> { UidHelper.nsec_uuid('POT', separator: '') }
+    end
+
+    def do_pay
+      p = {
+        openid: self.account_num,
+        amount: (self.requested_amount * 100).to_i,
+        partner_trade_no: self.payout_uuid,
+        check_name: 'NO_CHECK',
+        desc: 'd',
+        spbill_create_ip: '127.0.0.1'
+      }
+
+      r = WxPay::Service.invoke_transfer p
+      result = r.dig(:raw, 'xml')
+      if result['result_code'] == 'SUCCESS'
+        self.update state: 'done'
+      else
+        self.update state: 'failed'
+      end
+    rescue
+      self.update state: 'failed'
+    end
+
+  end
+end

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

@@ -0,0 +1,71 @@
+module Trade
+  module Model::Payout
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :type, :string
+      attribute :payout_uuid, :string
+      attribute :requested_amount, :decimal
+      attribute :actual_amount, :decimal
+      attribute :paid_at, :datetime
+      attribute :advance, :boolean, default: false
+      attribute :account_bank, :string
+      attribute :account_name, :string
+      attribute :account_num, :string
+
+      belongs_to :cash
+      belongs_to :operator, class_name: 'User', optional: true
+      belongs_to :payable, polymorphic: true, optional: true
+
+      has_one :cash_log, ->(o) { where(cash_id: o.cash_id) }, as: :source
+
+      has_one_attached :proof
+
+      enum state: {
+        pending: 'pending',
+        done: 'done',
+        failed: 'failed'
+      }, _default: 'pending'
+
+      before_validation do
+        self.payout_uuid ||= UidHelper.nsec_uuid('POT')
+      end
+      #before_save :sync_state
+      after_save :sync_to_cash, if: -> { saved_change_to_requested_amount? }
+      after_create_commit :sync_cash_log
+    end
+
+    def sync_state
+      if requested_amount == actual_amount
+        self.state = 'done'
+
+        if advance
+          payable.do_trigger(state: 'advance_paid')
+        else
+          payable.do_trigger(state: 'paid')
+        end
+      end
+    end
+
+    def sync_to_cash
+      (self.cash && cash.reload) || create_cash
+
+      cash.expense_amount += self.requested_amount
+      if cash.expense_amount == cash.compute_expense_amount
+        cash.save!
+      else
+        cash.errors.add :expense_amount, 'not equal'
+        raise ActiveRecord::RecordInvalid.new(cash)
+      end
+    end
+
+    def sync_cash_log
+      cl = self.cash_log || self.build_cash_log
+      cl.title = '提现'
+      cl.tag_str = '支出'
+      cl.amount = -self.requested_amount
+      cl.save
+    end
+
+  end
+end

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

@@ -0,0 +1,33 @@
+# see RailsBooking::PlanAttender
+module Trade
+  module Model::PlanAttender
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :card_payments
+      has_many :card_returns, as: :consumable
+
+      after_save_commit :sync_card_expense, if: -> { saved_change_to_attended? && attended? }
+      after_commit :sync_card_return, if: -> { saved_change_to_attended? && !attended? }
+    end
+
+    def sync_card_expense
+      return unless self.attender.cards.present?
+      card_id = self.attender.card_ids.first
+
+      log = self.card_expenses.build(card_id: card_id)
+      log.amount = plan_item.planned.price
+      log.save
+      log
+    end
+
+    def sync_card_return
+      self.card_expenses.map do |card_expense|
+        log = self.card_returns.build(card_expense_id: card_expense.id)
+        log.save
+        log
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,10 @@
+module Trade
+  module Model::Profile
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :cards, as: :client
+    end
+
+  end
+end

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

@@ -0,0 +1,59 @@
+module Trade
+  module Model::Promote
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :name, :string
+      attribute :short_name, :string
+      attribute :code, :string
+      attribute :description, :string
+      attribute :scope, :string
+      attribute :metering, :string
+      attribute :editable, :boolean, default: false, comment: '是否可更改价格'
+      attribute :verified, :boolean, default: false
+      attribute :extra, :json
+
+      belongs_to :organ, optional: true
+      belongs_to :deal, polymorphic: true, optional: true
+      has_many :promote_charges, dependent: :delete_all
+      has_many :promote_extras, dependent: :delete_all
+      has_many :promote_goods, dependent: :destroy
+      has_many :promote_carts, dependent: :destroy
+
+      scope :verified, -> { where(verified: true) }
+      scope :default, -> { verified.where(default: true) }
+      scope :for_sale, -> { verified.where(default: false) }
+
+      validates :code, uniqueness: true, allow_blank: true
+
+      enum scope: {
+        single: 'single',  # 适用于单独计算商品
+        overall: 'overall'  # 适用于多个商品一起计算
+      }
+      enum metering: {
+        number: 'number',  # 商品购买件数
+        weight: 'weight',  # 商品总重量，support sequence
+        volume: 'volume',  # 商品总体积, support sequence
+        original_amount: 'original_amount'  # 商品总金额, support sequence
+      }
+    end
+
+    def extra_mappings
+      promote_extras.pluck(:extra_name, :column_name).to_h
+    end
+
+    def compute_charge(value, **extra)
+      extra.transform_keys! { |key| extra_mappings[key.to_s] }
+      extra.delete nil
+
+      q_params = {
+        'min-lte': value,
+        'max-gte': value,
+        **extra
+      }
+
+      promote_charges.default_where(q_params).take
+    end
+
+  end
+end