rails_trade 0.0.1

data/app/models/rails_trade/produce.rb

@@ -0,0 +1,18 @@
+class Produce < ApplicationRecord
+  has_many :good_produces
+
+end unless RailsTrade.config.disabled_models.include?('Produce')
+
+=begin
+
+# 生产工艺
+
+t.string   "product",    limit: 255
+t.string   "name",       limit: 255
+t.text     "content",    limit: 65535
+t.datetime "start_at"
+t.datetime "finish_at"
+t.datetime "created_at"
+t.datetime "updated_at"
+
+=end

data/app/models/rails_trade/promote.rb

@@ -0,0 +1,40 @@
+class Promote < ApplicationRecord
+  attr_accessor :price
+
+  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
+  end
+
+  def self.sequence
+    Rails.cache.fetch('promotes/sequence') do
+      self.select(:sequence).distinct.pluck(:sequence).sort
+    end
+  end
+
+  private
+  def delete_cache
+    ['promotes/sequence'].each do |c|
+      Rails.cache.delete(c)
+    end
+  end
+
+end unless RailsTrade.config.disabled_models.include?('Promote')
+
+# :start_at, :datetime
+# :finish_at, :datetime

data/app/models/rails_trade/promote_buyer.rb

@@ -0,0 +1,9 @@
+class PromoteBuyer < ApplicationRecord
+  belongs_to :promote
+
+
+end unless RailsTrade.config.disabled_models.include?('PromoteBuyer')
+
+# :order_id, :integer
+# :order_item_id :integer
+

data/app/models/rails_trade/promote_charge.rb

@@ -0,0 +1,17 @@
+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 } }
+
+  def final_price(amount = 1)
+    raise 'Should Implement in Subclass'
+  end
+
+end unless RailsTrade.config.disabled_models.include?('PromoteCharge')
+
+# :min, :integer
+# :max, :integer
+# :price, :decimal
+# :type, :string     # SingleCharge / TotalCharge

data/app/models/rails_trade/promote_charges/single_promote_charge.rb

@@ -0,0 +1,7 @@
+class SinglePromoteCharge < PromoteCharge
+
+  def final_price(amount)
+    (price * amount).round(2)
+  end
+
+end

data/app/models/rails_trade/promote_charges/total_promote_charge.rb

@@ -0,0 +1,7 @@
+class TotalPromoteCharge < PromoteCharge
+
+  def final_price(amount = nil)
+    price.round(2)
+  end
+
+end

data/app/models/rails_trade/promote_good.rb

@@ -0,0 +1,9 @@
+class PromoteGood < ApplicationRecord
+  belongs_to :good, polymorphic: true
+  belongs_to :promote
+
+end unless RailsTrade.config.disabled_models.include?('PromoteGood')
+
+# :order_id, :integer
+# :order_item_id :integer
+

data/app/models/rails_trade/promotes/amount_promote.rb

@@ -0,0 +1,4 @@
+class AmountPromote < Promote
+
+
+end

data/app/models/rails_trade/promotes/number_promote.rb

@@ -0,0 +1,4 @@
+class NumberPromote < Promote
+
+
+end

data/app/models/rails_trade/provider.rb

@@ -0,0 +1,25 @@
+class Provider < ApplicationRecord
+  belongs_to :area, optional: true
+  has_many :users, inverse_of: :provider
+  has_many :products
+
+  def name_detail
+    "#{name} (#{id})"
+  end
+
+end unless RailsTrade.config.disabled_models.include?('Provider')
+
+=begin
+
+create_table "providers", force: :cascade do |t|
+  t.string   "name",        limit: 255
+  t.string   "logo",        limit: 255
+  t.string   "address",     limit: 255
+  t.integer  "area_id",     limit: 4
+  t.datetime "created_at",              null: false
+  t.datetime "updated_at",              null: false
+  t.string   "service_tel", limit: 255
+  t.string   "service_qq",  limit: 255
+end
+
+=end

data/app/models/rails_trade/refund.rb

@@ -0,0 +1,63 @@
+class Refund < ApplicationRecord
+  attribute :currency, :string, default: 'USD'
+
+  belongs_to :operator, polymorphic: true, optional: true
+  belongs_to :order, inverse_of: :refunds, optional: true
+  belongs_to :payment
+
+  validates :payment_id, uniqueness: { scope: :order_id }
+
+  after_initialize if: -> { new_record? } do
+    self.refund_uuid = UidHelper.nsec_uuid('RD')
+    self.state = :init
+  end
+
+  enum state: [
+    :init,
+    :completed,
+    :failed
+  ]
+
+  #validate :valid_total_amount
+
+  # 微信是同一个批次号未退款成功可重复申请
+  # 支付宝批次号只能当天有效
+
+  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 do_refund(params = {})
+    order.payment_status = 'refunded'
+
+    self.state = 'completed'
+    self.refunded_at = Time.now
+
+    self.class.transaction do
+      order.save!
+      self.save!
+    end
+  end
+
+  def deny_refund(params = {})
+    order.payment_status = 'denied'
+
+    self.state = 'failed'
+
+    self.class.transaction do
+      order.save!
+      self.save!
+    end
+  end
+
+  def can_refund?
+    self.init? && ['all_paid', 'part_paid', 'refunding'].include?(order.payment_status)
+  end
+
+end unless RailsTrade.config.disabled_models.include?('Refund')

data/app/models/rails_trade/refunds/alipay_refund.rb

@@ -0,0 +1,33 @@
+class AlipayRefund < Refund
+  
+  def do_refund(params = {})
+    return unless can_refund?
+
+    refund_params = {
+      out_trade_no: self.order.uuid,
+      refund_amount: self.total_amount.to_s,
+      out_request_no: self.refund_uuid
+    }
+
+    refund_res = Alipay::Service.trade_refund(refund_params)
+
+    order.payment_status = 'refunded'
+    self.operator_id = params[:operator_id]
+
+    refund = JSON.parse(refund_res).fetch('alipay_trade_refund_response', {})
+
+    if refund['code'] == '10000' || refund['msg'] == 'Success'
+      self.refund_uuid = refund['trade_no']
+      self.state = 'completed'
+      self.refunded_at = Time.now
+      self.class.transaction do
+        order.save!
+        self.save!
+      end
+    else
+      self.update reason: "code: #{refund['code']}, msg: #{refund['msg']}"
+    end
+    refund
+  end
+
+end

data/app/models/rails_trade/refunds/bank_refund.rb

@@ -0,0 +1,5 @@
+class BankRefund < Refund
+
+
+
+end

data/app/models/rails_trade/refunds/hand_refund.rb

@@ -0,0 +1,5 @@
+class HandRefund < Refund
+
+
+
+end

data/app/models/rails_trade/refunds/paypal_refund.rb

@@ -0,0 +1,32 @@
+class PaypalRefund < Refund
+
+  def do_refund(params = {})
+    return unless can_refund?
+    sale = PayPal::SDK::REST::DataTypes::Sale.find(payment.payment_uuid)
+
+    params = params.merge({
+      amount: {
+        total: self.total_amount.to_s(:rounded, precision: 2),
+        currency: self.currency.upcase
+      }
+    })
+
+    result = sale.refund(params)
+
+    order.payment_status = 'refunded'
+    self.operator_id = params[:operator_id]
+
+    if result.success?
+      self.state = 'completed'
+      self.refunded_at = Time.now
+      self.class.transaction do
+        order.save!
+        self.save!
+      end
+    elsif result.error
+      self.update reason: result.error['message']
+    end
+    result
+  end
+
+end

data/app/models/rails_trade/refunds/stripe_refund.rb

@@ -0,0 +1,26 @@
+class StripeRefund < Refund
+
+  def do_refund(params = {})
+    return unless can_refund?
+
+    refund = Stripe::Refund.create(charge: payment.payment_uuid, amount: (self.total_amount * 100).to_i)
+
+    order.payment_status = 'refunded'
+
+    self.operator_id = params[:operator_id]
+    self.refund_uuid = refund.id
+
+    if refund.status == 'succeeded'
+      self.state = 'completed'
+      self.refunded_at = Time.now
+      self.class.transaction do
+        order.save!
+        self.save!
+      end
+    else
+      self.update reason: 'failed'
+    end
+    refund
+  end
+
+end

data/app/models/rails_trade/refunds/wxpay_refund.rb

@@ -0,0 +1,40 @@
+class WxpayRefund < Refund
+
+  def transaction_id
+    refunded_payment&.payment_uuid
+  end
+
+  def out_trade_no
+    self.origin&.payment_entity_no
+  end
+
+  def do_refund(params = {})
+    params = {
+      out_refund_no: self.refund_uuid,
+      total_fee: (payment.total_amount * 100).to_i,
+      refund_fee: (total_amount * 100).to_i,
+      transaction_id: self.payment.payment_uuid
+    }
+
+    begin
+      result = WxPay::Service.invoke_refund(params)
+      if result['result_code'] == 'SUCCESS'
+        self.update(state: 'completed')
+      else
+        self.update(state: 'failed', comment: result['result_code'])
+      end
+    rescue StandardError => e
+      result = e.message
+      self.update(state: 'failed', comment: result.truncate(225))
+    end
+    result
+  end
+
+  def refund_query
+    params = {
+      out_refund_no: self.refund_uuid
+    }
+    result = WxPay::Service.refund_query(params)
+  end
+
+end

data/app/models/rails_trade/serve.rb

@@ -0,0 +1,44 @@
+class Serve < ApplicationRecord
+  attr_accessor :price
+  serialize :extra, Array
+
+  belongs_to :deal, polymorphic: true, optional: true
+  has_many :charges, class_name: 'ServeCharge', dependent: :delete_all
+  has_many :serve_goods, dependent: :delete_all
+
+  scope :verified, -> { where(verified: true) }
+  scope :special, -> { where(verified: true, overall: false) }
+  scope :overall, -> { where(verified: true, overall: true) }
+  scope :default, -> { where(verified: true, default: true) }
+  scope :for_sale, -> { where(verified: true, default: false) }
+
+  enum scope: {
+    'total': 'total',
+    'single': 'single'
+  }
+
+  def compute_price(amount, extra_hash = {})
+    extra_hash.stringify_keys!
+
+    if self.contain_max
+      range = { 'min-lte': amount.to_d, 'max-gte': amount.to_d }
+    else
+      range = { 'min-lte': amount.to_d, 'max-gt': amount.to_d }
+    end
+
+    query = range.merge(extra_hash.slice(*extra))
+    charge = self.charges.default_where(query).first
+    if charge
+      charge.subtotal = charge.final_price(amount)
+      charge.default_subtotal = charge.subtotal
+    else
+      charge = self.charges.build
+      charge.subtotal = 0
+    end
+    charge
+  end
+
+end unless RailsTrade.config.disabled_models.include?('Serve')
+
+# :start_at, :datetime
+# :finish_at, :datetime

data/app/models/rails_trade/serve_charge.rb

@@ -0,0 +1,37 @@
+class ServeCharge < ApplicationRecord
+  attr_accessor :subtotal, :default_subtotal, :cart_item_serve
+  belongs_to :item, class_name: 'Serve', foreign_key: :serve_id
+
+  validates :max, numericality: { greater_than: -> (o) { o.min } }
+  validates :min, numericality: { less_than: -> (o) { o.max } }
+
+  def final_price(amount = 1)
+    raise 'Should Implement in Subclass'
+  end
+
+  def extra
+    self.attributes.slice(*item.extra)
+  end
+
+  def self.min_step
+    0.1.to_d.power(ServeCharge.columns_hash['min'].scale)
+  end
+
+  def self.max_step
+    0.1.to_d.power(ServeCharge.columns_hash['max'].scale)
+  end
+
+  def self.extra_columns
+    ServeCharge.attribute_names - ['id', 'serve_id', 'min', 'max', 'price', 'base_price', 'type', 'created_at', 'updated_at']
+  end
+
+  def self.extra_options
+    extra_columns.map { |extra_column| [ServeCharge.human_attribute_name(extra_column), extra_column] }.to_h
+  end
+
+end unless RailsTrade.config.disabled_models.include?('ServeCharge')
+
+# :min, :integer
+# :max, :integer
+# :price, :decimal
+# :type, :string     # SingleCharge / TotalCharge