rails_trade 0.0.1 → 0.0.2

data/app/models/rails_trade/payment_reference.rb

@@ -1,15 +1,18 @@
-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?
+module RailsTrade::PaymentReference
+  extend ActiveSupport::Concern
+  included do
+    attribute :state, :string
+    
+    belongs_to :payment_method, inverse_of: :payment_references
+    belongs_to :buyer, polymorphic: true
+  
+    before_save :prevent_duplicate
   end
-
+  
   def prevent_duplicate
-    if PaymentReference.exists?(payment_method_id: self.payment_method_id, buyer_id: self.buyer_id)
+    if PaymentReference.exists?(payment_method_id: self.payment_method_id, buyer_id: self.buyer_id, buyer_type: self.buyer_type)
       throw(:abort)
     end
   end
 
-end unless RailsTrade.config.disabled_models.include?('PaymentReference')
+end

data/app/models/rails_trade/payment_strategy.rb

@@ -1,16 +1,19 @@
-class PaymentStrategy < ApplicationRecord
-
-
+module RailsTrade::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 unless RailsTrade.config.disabled_models.include?('PaymentStrategy')
-
-
-# :name, comment: '名称'
-# :period, comment: '可延期时间，单位天'
-
-# 预付全款
-# 预付定金
-# 后付
+end

data/app/models/rails_trade/payment_type/alipay.rb

@@ -0,0 +1,28 @@
+module RailsTrade::PaymentType::Alipay
+
+  def alipay_prepay
+    self.update payment_type: 'alipay'
+    Alipay2::Service.trade_app_pay_params(subject: self.subject, out_trade_no: self.uuid, total_amount: self.amount.to_s)
+  end
+
+  def alipay_prepay_url
+    self.update payment_type: 'alipay'
+    Alipay2::Service.trade_page_pay subject: self.subject, out_trade_no: self.uuid, total_amount: self.amount.to_s
+  end
+
+  def alipay_result
+    return self if self.payment_status == 'all_paid'
+
+    result = Alipay2::Service.trade_query out_trade_no: self.uuid
+    result = JSON.parse(result)
+    result = result['alipay_trade_query_response']
+
+    if result['trade_status'] == 'TRADE_SUCCESS'
+      self.change_to_paid! type: 'AlipayPayment', payment_uuid: result['trade_no'], params: result
+    else
+      errors.add :base, result['msg']
+      logger.error "Alipay: #{self.errors.full_messages.join(', ')}"
+    end
+  end
+
+end

data/app/models/rails_trade/payment_type/apple_pay.rb

@@ -0,0 +1,18 @@
+module RailsTrade::PaymentType::ApplePay
+
+  def apple_pay_result(receipt_data)
+    return self if self.payment_status == 'all_paid'
+
+    result = ApplePay.query receipt_data
+
+    result['product_id'] == self.uuid
+    result['amount'] = self.amount
+
+    if result['trade_status'] == 'TRADE_SUCCESS'
+      self.change_to_paid! type: 'ApplePayment', payment_uuid: result['transaction_id'], params: result
+    else
+      errors.add :base, result['msg']
+    end
+  end
+
+end

data/app/models/rails_trade/{payment_interface/the_paypal.rb → payment_type/paypal.rb}

@@ -1,9 +1,4 @@
-module ThePaypal
-  extend ActiveSupport::Concern
-
-  included do
-    delegate :url_helpers, to: 'Rails.application.routes'
-  end
+module RailsTrade::PaymentType::Paypal
 
   def paypal_prepay
     paypal_payment = PayPal::SDK::REST::DataTypes::Payment.new(paypal_params)
@@ -26,32 +21,16 @@ module ThePaypal
   end
 
   def paypal_result
-    return unless self.payment_id
-    self.paypal_payment ||= PayPal::SDK::REST::DataTypes::Payment.find(self.payment_id)
-
-    paypal_record(paypal_payment)
-  end
-
-  def paypal_record(record)
-    trans = record.transactions[0]
-
-    if record.state == 'approved'
-      paypal = PaypalPayment.find_by(payment_uuid: trans.related_resources[0].sale.id)
-      return paypal if paypal
+    return self if self.payment_status == 'all_paid'
 
-      paypal = PaypalPayment.new
-      paypal.payment_uuid = trans.related_resources[0].sale.id
-      paypal.total_amount = trans.amount.total
-
-      payment_order = paypal.payment_orders.build(order_id: self.id, check_amount: paypal.total_amount)
+    return unless self.payment_id
+    paypal_payment ||= PayPal::SDK::REST::DataTypes::Payment.find(self.payment_id)
+    trans = paypal_payment.transactions[0]
 
-      Payment.transaction do
-        payment_order.confirm!
-        paypal.save!
-      end
-      paypal
+    if paypal_payment.state == 'approved'
+      self.change_to_paid! type: 'PaypalPayment', payment_uuid: trans.related_resources[0].sale.id, params: trans
     else
-      errors.add :uuid, record.error.inspect
+      errors.add :base, paypal_payment.error.inspect
     end
   end
 

data/app/models/rails_trade/{payment_interface/the_stripe.rb → payment_type/stripe.rb}

@@ -1,8 +1,4 @@
-module TheStripe
-  extend ActiveSupport::Concern
-
-  included do
-  end
+module RailsTrade::PaymentType::Stripe
 
   def stripe_charge(params = {})
     if params[:token]
@@ -32,31 +28,17 @@ module TheStripe
   end
 
   def stripe_result
+    return self if self.payment_status == 'all_paid'
+
     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!
+      if charge.paid && !charge.refunded
+         self.change_to_paid! type: 'StripePayment', payment_uuid: charge.id, params: charge
+      else
+        errors.add :uuid, 'error'
       end
-      stripe
-    else
-      errors.add :uuid, 'error'
+
     end
   end
 

data/app/models/rails_trade/payment_type/wxpay.rb

@@ -0,0 +1,55 @@
+module RailsTrade::PaymentType::Wxpay
+
+  def wxpay_prepay(trade_type: 'JSAPI', spbill_create_ip: '127.0.0.0', notify_url: url_helpers.wxpay_notify_payments_url, **options)
+    appid = options[:appid] || ::WxPay.appid
+    params = {
+      body: "订单编号: #{self.uuid}",
+      out_trade_no: self.uuid,
+      total_fee: (self.amount * 100).to_i,
+      spbill_create_ip: spbill_create_ip,
+      notify_url: notify_url,
+      trade_type: trade_type,
+      openid: user.oauth_users.find_by(app_id: appid)&.uid
+    }
+    
+    ::WxPay::Service.invoke_unifiedorder params, options
+  end
+
+  def wxpay_order(trade_type: 'JSAPI', **options)
+    prepay = wxpay_prepay(trade_type: trade_type, **options)
+
+    if prepay.success?
+      params = {
+        noncestr: prepay['nonce_str'],
+        prepayid: prepay['prepay_id']
+      }
+      if trade_type == 'JSAPI'
+        ::WxPay::Service.generate_js_pay_req params, options
+      else
+        ::WxPay::Service.generate_app_pay_req params, options
+      end
+    else
+      prepay.except(:raw)
+    end
+  end
+
+  def wxpay_result(options = {})
+    return self if self.payment_status == 'all_paid'
+
+    params = {
+      out_trade_no: self.uuid,
+    }
+    begin
+      result = WxPay::Service.order_query params, options
+    rescue
+      result = { 'err_code_des' => 'network error' }
+    end
+
+    if result['trade_state'] == 'SUCCESS'
+      self.change_to_paid! type: 'WxpayPayment', payment_uuid: result['transaction_id'], params: result
+    else
+      self.errors.add :base, result['err_code_des']
+    end
+  end
+
+end

data/app/models/rails_trade/promote.rb

@@ -1,30 +1,63 @@
-class Promote < ApplicationRecord
-  attr_accessor :price
+module RailsTrade::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 :effect_at, :datetime
+    attribute :expire_at, :datetime
+    attribute :sequence, :integer, default: 1
+    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_buyers, dependent: :destroy
+    
+    scope :verified, -> { where(verified: true) }
+    scope :default, -> { verified.where(default: true) }
+    scope :for_sale, -> { verified.where(default: false) }
+    scope :valid, -> { t = Time.current; verified.default_where('effect_at-lte': t, 'expire_at-gte': t) }
 
-  has_many :charges, class_name: 'PromoteCharge', dependent: :delete_all
-
-  scope :special, -> { where(verified: true, overall: false) }
-  scope :overall, -> { where(verified: true, overall: true) }
-
-  after_commit :delete_cache, on: [:create, :destroy]
-  #after_update_commit :delete_cache, if: -> { sequence_changed? }
-
-  enum scope: {
-    'total': 'total',
-    'single': 'single'
-  }
-
-  def compute_price(amount, extra = {})
-    query = { 'min-lte': amount.to_d, 'max-gt': amount.to_d }.merge(extra)
-    charge = self.charges.default_where(query).first
-    charge.subtotal = charge.final_price(amount) if charge
-    charge
+    validates :code, uniqueness: true, allow_blank: true
+    
+    after_commit :delete_cache, on: [:create, :destroy]
+    after_update_commit :delete_cache, if: -> { saved_change_to_sequence? }
+  
+    enum scope: {
+      single: 'single',  # 适用于单独计算商品
+      overall: 'overall' # 适用于多个商品一起计算
+    }
+    enum metering: {
+      number: 'number',  # 商品购买件数
+      weight: 'weight',  # 商品总重量，support sequence
+      volume: 'volume',  # 商品总体积, support sequence
+      amount: 'amount'  # 商品总金额, support sequence
+    }
+  end
+  
+  def extra_mappings
+    promote_extras.pluck(:extra_name, :column_name).to_h
   end
 
-  def self.sequence
-    Rails.cache.fetch('promotes/sequence') do
-      self.select(:sequence).distinct.pluck(:sequence).sort
-    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
 
   private
@@ -34,7 +67,12 @@ class Promote < ApplicationRecord
     end
   end
 
-end unless RailsTrade.config.disabled_models.include?('Promote')
+  class_methods do
+    def sequence
+      Rails.cache.fetch('promotes/sequence') do
+        self.select(:sequence).distinct.pluck(:sequence).sort
+      end
+    end
+  end
 
-# :start_at, :datetime
-# :finish_at, :datetime
+end

data/app/models/rails_trade/promote_buyer.rb

@@ -1,9 +1,27 @@
-class PromoteBuyer < ApplicationRecord
-  belongs_to :promote
+module RailsTrade::PromoteBuyer
+  extend ActiveSupport::Concern
+  included do
+    attribute :state, :string, default: 'unused'
+    attribute :status, :string, default: 'available'
+    attribute :effect_at, :datetime
+    attribute :expire_at, :datetime
+    attribute :trade_promotes_count, :integer, default: 0
+    
+    belongs_to :promote
+    belongs_to :promote_good, optional: true
+    belongs_to :buyer, polymorphic: true
+    has_many :trade_promotes, dependent: :nullify
+    
+    enum state: {
+      unused: 'unused',
+      used: 'used'
+    }
 
+    scope :valid, -> { t = Time.current; unused.default_where('expire_at-gte': t, 'effect_at-lte': t) }
+    
+    before_validation do
+      self.promote = self.promote_good.promote
+    end
+  end
 
-end unless RailsTrade.config.disabled_models.include?('PromoteBuyer')
-
-# :order_id, :integer
-# :order_item_id :integer
-
+end

data/app/models/rails_trade/promote_charge.rb

@@ -1,17 +1,84 @@
-class PromoteCharge < ApplicationRecord
-  attr_accessor :subtotal
-  belongs_to :item, class_name: 'Promote', foreign_key: :promote_id
-
-  validates :max, numericality: { greater_than: -> (o) { o.min } }
-  validates :min, numericality: { less_than: -> (o) { o.max } }
+module RailsTrade::PromoteCharge
+  COLUMN_NAMES = [
+    'id',
+    'promote_id',
+    'min',
+    'max',
+    'filter_min',
+    'filter_max',
+    'contain_min',
+    'contain_max',
+    'parameter',
+    'base_price',
+    'type',
+    'metering',
+    'unit',
+    'created_at',
+    'updated_at'
+  ].freeze
+  extend ActiveSupport::Concern
+  
+  included do
+    attribute :type, :string
+    attribute :unit, :string
+    attribute :min, :decimal, precision: 10, scale: 2, default: 0
+    attribute :max, :decimal, precision: 10, scale: 2, default: 99999999.99
+    attribute :filter_min, :decimal, precision: 10, scale: 2, default: 0
+    attribute :filter_max, :decimal, precision: 10, scale: 2, default: 99999999.99
+    attribute :contain_min, :boolean, default: true
+    attribute :contain_max, :boolean, default: false
+    attribute :parameter, :decimal, precision: 10, scale: 2, default: 0
+    attribute :base_price, :decimal, precision: 10, scale: 2, default: 0
+    
+    belongs_to :promote
+    
+    scope :filter_with, ->(amount){ default_where('filter_min-lte': amount, 'filter_max-gte': amount) }
 
+    validates :max, numericality: { greater_than_or_equal_to: -> (o) { o.min } }
+    validates :min, numericality: { less_than_or_equal_to: -> (o) { o.max } }
+    #validates :min, uniqueness: { scope: [:contain_min, :contain_max] }  # todo
+    before_validation :compute_filter_value
+  end
+  
+  # amount: 商品价格
+  # return 计算后的价格
   def final_price(amount = 1)
     raise 'Should Implement in Subclass'
   end
+  
+  def compute_filter_value
+    if contain_min
+      self.filter_min = min
+    else
+      self.filter_min = min + self.class.min_step
+    end
+    if contain_max
+      self.filter_max = max
+    else
+      self.filter_max = max - self.class.max_step
+    end
+  end
+
+  def extra
+    self.attributes.slice(*PromoteCharge.extra_columns)
+  end
+
+  class_methods do
+    def min_step
+      0.1.to_d.power(self.columns_hash['min'].scale)
+    end
 
-end unless RailsTrade.config.disabled_models.include?('PromoteCharge')
+    def max_step
+      0.1.to_d.power(self.columns_hash['max'].scale)
+    end
 
-# :min, :integer
-# :max, :integer
-# :price, :decimal
-# :type, :string     # SingleCharge / TotalCharge
+    def extra_columns
+      self.column_names - COLUMN_NAMES
+    end
+
+    def extra_options
+      extra_columns.map { |extra_column| [self.human_attribute_name(extra_column), extra_column] }.to_h
+    end
+  end
+  
+end