rails_trade 0.0.1

data/app/models/rails_trade/payment_interface/the_stripe.rb

@@ -0,0 +1,73 @@
+module TheStripe
+  extend ActiveSupport::Concern
+
+  included do
+  end
+
+  def stripe_charge(params = {})
+    if params[:token]
+      TheStripe.stripe_customer(buyer: self.buyer, token: params[:token])
+    end
+
+    if params[:payment_method_id]
+      stripe_payment_method = buyer.payment_methods.where(type: 'StripeMethod', id: params[:payment_method_id]).first
+    else
+      stripe_payment_method = buyer.payment_methods.where(type: 'StripeMethod').first
+    end
+
+    unless stripe_payment_method
+      self.errors.add :base, 'Please add credit card at first.'
+      return self
+    end
+    return self if self.amount <= 0
+
+    begin
+      charge = Stripe::Charge.create(amount: self.amount_money.cents, currency: self.currency, customer: stripe_payment_method.account_num)
+      self.update payment_type: 'stripe', payment_id: charge.id
+      self.stripe_record(charge)
+    rescue Stripe::StripeError, Stripe::CardError => ex
+      self.errors.add :base, ex.message
+    end
+    self
+  end
+
+  def stripe_result
+    if self.payment_id.present?
+      charge = Stripe::Charge.retrieve(self.payment_id)
+      self.stripe_record(charge)
+    end
+  end
+
+  def stripe_record(charge)
+    if charge.paid && !charge.refunded
+      existing = StripePayment.find_by(payment_uuid: charge.id)
+      return existing if existing
+
+      stripe = StripePayment.new
+      stripe.payment_uuid = charge.id
+      stripe.total_amount = Money.new(charge.amount, self.currency).to_d
+      stripe.currency = charge.currency.upcase
+
+      payment_order = stripe.payment_orders.build(order_id: self.id, check_amount: stripe.total_amount)
+
+      Payment.transaction do
+        payment_order.confirm!
+        stripe.save!
+      end
+      stripe
+    else
+      errors.add :uuid, 'error'
+    end
+  end
+
+  # execute payment
+  # required:
+  # token
+  def self.stripe_customer(buyer:, **params)
+    payment_method = buyer.payment_methods.build(type: 'StripeMethod')
+    payment_method.token = params[:token]
+    payment_method.detective_save
+    payment_method
+  end
+
+end

data/app/models/rails_trade/payment_interface/the_wxpay.rb

@@ -0,0 +1,56 @@
+module TheWxpay
+  extend ActiveSupport::Concern
+
+  included do
+    attr_accessor :openid, :spbill_create_ip
+    delegate :url_helpers, to: 'Rails.application.routes'
+  end
+
+  def wxpay_prepay
+    return @wxpay_prepay if @wxpay_prepay
+    params = {
+      body: "订单编号: #{self.uuid}",
+      out_trade_no: self.uuid,
+      total_fee: (self.amount * 100).to_i,
+      spbill_create_ip: spbill_create_ip,
+      notify_url: url_helpers.wxpay_notify_payments_url,
+      trade_type: 'JSAPI',
+      openid: openid
+    }
+    @wxpay_prepay = WxPay::Service.invoke_unifiedorder params
+  end
+
+  def wxpay_order
+    return @wxpay_order if @wxpay_order
+
+    prepay = wxpay_prepay
+    if prepay['result_code'] == 'SUCCESS'
+      params = {
+        noncestr: prepay['nonce_str'],
+        prepayid: prepay['prepay_id']
+      }
+      @wxpay_order = WxPay::Service.generate_js_pay_req params
+    elsif prepay['result_code'] == 'FAIL'
+      @wxpay_order = {
+        result_code: 'FAIL',
+        err_code: prepay['err_code'],
+        err_code_des: prepay['err_code_des']
+      }
+    else
+      @wxpay_order = {}
+    end
+  end
+
+  def wxpay_result
+    params = {
+      out_trade_no: self.uuid,
+    }
+    result = WxPay::Service.order_query params
+    wxpay_record(result)
+  end
+
+  def wxpay_record(result)
+
+  end
+
+end

data/app/models/rails_trade/payment_method.rb

@@ -0,0 +1,57 @@
+class PaymentMethod < ApplicationRecord
+  serialize :extra, Hash
+
+  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?
+
+  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 unless RailsTrade.config.disabled_models.include?('PaymentMethod')
+
+
+

data/app/models/rails_trade/payment_methods/alipay_method.rb

@@ -0,0 +1,7 @@
+class AlipayMethod < PaymentMethod
+
+
+end
+
+
+

data/app/models/rails_trade/payment_methods/bank_method.rb

@@ -0,0 +1,7 @@
+class BankMethod < PaymentMethod
+
+
+end
+
+
+

data/app/models/rails_trade/payment_methods/stripe_method.rb

@@ -0,0 +1,57 @@
+class StripeMethod < PaymentMethod
+  attr_accessor :token
+  after_destroy_commit :remove
+
+  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
+
+
+

data/app/models/rails_trade/payment_order.rb

@@ -0,0 +1,75 @@
+class PaymentOrder < ApplicationRecord
+  belongs_to :order, inverse_of: :payment_orders
+  belongs_to :payment, inverse_of: :payment_orders
+
+  validate :for_check_amount
+
+  enum state: [
+    :init,
+    :confirmed
+  ]
+
+  def for_check_amount
+    if (same_payment_amount + self.check_amount.to_d) >= self.payment.total_amount.floor + 0.99
+      self.errors.add(:check_amount, 'The Amount Large than the Total Payment')
+    end
+
+    if (same_order_amount + self.check_amount.to_d) >= self.order.amount.floor + 0.99
+      self.errors.add(:check_amount, 'The Amount Large than the Total Order')
+    end
+  end
+
+  def same_payment_amount
+    PaymentOrder.where.not(id: self.id).where(payment_id: self.payment_id).sum(:check_amount)
+  end
+
+  def same_order_amount
+    received = PaymentOrder.where.not(id: self.id).where(order_id: self.order_id).sum(:check_amount)
+    refund = Refund.where(payment_id: payment_id, order_id: order_id).sum(:total_amount)
+    received - refund
+  end
+
+  def payment_amount
+    PaymentOrder.where(payment_id: self.payment_id, state: 'confirmed').sum(:check_amount)
+  end
+
+  def order_amount
+    PaymentOrder.where(order_id: self.order_id, state: 'confirmed').sum(:check_amount)
+  end
+
+  def confirm!
+    self.state = 'confirmed'
+
+    begin
+      self.save!
+
+      self.class.transaction do
+        update_order_state
+        update_payment_state
+      end
+    rescue => e
+      raise e
+    end
+  end
+
+  def revert_confirm!
+    self.state = 'init'
+    self.save!
+
+    self.class.transaction do
+      update_order_state
+      update_payment_state
+    end
+  end
+
+  def update_order_state
+    order.received_amount = order_amount
+    order.check_state!
+  end
+
+  def update_payment_state
+    payment.checked_amount = payment_amount
+    payment.check_state!
+  end
+
+end unless RailsTrade.config.disabled_models.include?('PaymentOrder')

data/app/models/rails_trade/payment_reference.rb

@@ -0,0 +1,15 @@
+class PaymentReference < ApplicationRecord
+  belongs_to :payment_method, inverse_of: :payment_references
+
+  before_save :prevent_duplicate
+  after_initialize if: :new_record? do |t|
+    self.buyer_id = self.user&.buyer_id if self.buyer_id.nil?
+  end
+
+  def prevent_duplicate
+    if PaymentReference.exists?(payment_method_id: self.payment_method_id, buyer_id: self.buyer_id)
+      throw(:abort)
+    end
+  end
+
+end unless RailsTrade.config.disabled_models.include?('PaymentReference')

data/app/models/rails_trade/payment_strategy.rb

@@ -0,0 +1,16 @@
+class PaymentStrategy < ApplicationRecord
+
+
+  def credit?
+    self.period.to_i > 0
+  end
+
+end unless RailsTrade.config.disabled_models.include?('PaymentStrategy')
+
+
+# :name, comment: '名称'
+# :period, comment: '可延期时间，单位天'
+
+# 预付全款
+# 预付定金
+# 后付

data/app/models/rails_trade/payments/alipay_payment.rb

@@ -0,0 +1,12 @@
+class AlipayPayment < Payment
+
+  def assign_detail(params)
+    self.notified_at = params['notify_time']
+    self.payment_uuid = params['trade_no']
+    self.pay_status = params['trade_status']
+    self.seller_identifier = params['seller_id']
+    self.buyer_identifier = params['buyer_id']
+    self.total_amount = params['total_amount']
+  end
+
+end

data/app/models/rails_trade/payments/bank_payment.rb

@@ -0,0 +1,15 @@
+class BankPayment < Payment
+  #validates :buyer_name, presence: true
+  #validates :buyer_identifier, presence: true
+  validates :payment_uuid, uniqueness: true
+
+  def assign_detail(params)
+    self.notified_at = Time.now
+    self.total_amount = params[:total_amount]
+    self.order_uuid = order.uuid
+    self.state = 'completed'
+    self.buyer_email = order.contact&.email
+    self.buyer_identifier = order.contact_id
+  end
+
+end

data/app/models/rails_trade/payments/hand_payment.rb

@@ -0,0 +1,13 @@
+class HandPayment < Payment
+
+  after_initialize if: :new_record? do |lb|
+    self.payment_uuid = UidHelper.nsec_uuid('PAY')
+  end
+
+  def assign_detail(params)
+    self.notified_at = Time.now
+    self.total_amount = params[:total_amount]
+    self.state = 'completed'
+  end
+
+end

data/app/models/rails_trade/payments/paypal_payment.rb

@@ -0,0 +1,8 @@
+class PaypalPayment < Payment
+  validates :payment_uuid, uniqueness: true
+
+  def assign_detail(params)
+
+  end
+
+end

data/app/models/rails_trade/payments/stripe_payment.rb

@@ -0,0 +1,7 @@
+class StripePayment < Payment
+
+  validates :payment_uuid, uniqueness: true
+
+
+
+end

data/app/models/rails_trade/payments/wxpay_payment.rb

@@ -0,0 +1,14 @@
+class WxpayPayment < Payment
+
+  def assign_detail(params)
+    self.sign = params['sign']
+    self.notified_at = params['time_end']
+    self.payment_uuid = params['transaction_id']
+    self.pay_status = params['result_code']
+    self.seller_identifier = params['mch_id']
+    self.buyer_identifier = params['openid']
+    self.total_amount = params['total_fee'].to_i / 100.0
+    self.fee_amount = (self.total_amount * 0.60 / 100).round(2)
+  end
+
+end