rails_trade 0.0.2 → 0.0.3

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

@@ -1,55 +0,0 @@
-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,78 +0,0 @@
-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) }
-
-    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 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
-  def delete_cache
-    ['promotes/sequence'].each do |c|
-      Rails.cache.delete(c)
-    end
-  end
-
-  class_methods do
-    def sequence
-      Rails.cache.fetch('promotes/sequence') do
-        self.select(:sequence).distinct.pluck(:sequence).sort
-      end
-    end
-  end
-
-end

data/app/models/rails_trade/promote_buyer.rb

@@ -1,27 +0,0 @@
-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

data/app/models/rails_trade/promote_charge/cash_promote_charge.rb

@@ -1,12 +0,0 @@
-# 抵扣券，如果抵扣券金额大于总额，则为0
-module RailsTrade::PromoteCharge::CashPromoteCharge
-
-  def final_price(amount)
-    if parameter.abs >= amount
-      - amount
-    else
-      - parameter.abs
-    end
-  end
-
-end

data/app/models/rails_trade/promote_charge/discount_promote_charge.rb

@@ -1,17 +0,0 @@
-# 折扣价格
-module RailsTrade::PromoteCharge::DiscountPromoteCharge
-
-  # 用户输入参数可为
-  # 正数的折扣，原价 * 折扣， 如 100 * 0.7， parameter 为0.7
-  # 负数的折扣，原价 * （1+折扣），如 100 * (1-0.3), parameter 为 -0.3
-  def final_price(amount)
-    if parameter < 0 && parameter > -1
-      (amount * parameter).round(2)
-    elsif parameter > 0 && parameter < 1
-      -(amount * (1 - parameter)).round(2)
-    else
-      amount
-    end
-  end
-
-end

data/app/models/rails_trade/promote_charge/final_promote_charge.rb

@@ -1,12 +0,0 @@
-# 一口价
-module RailsTrade::PromoteCharge::FinalPromoteCharge
-  extend ActiveSupport::Concern
-  included do
-  end
-  
-  # 返回原价与一口价之间的差，负数。
-  def final_price(amount)
-    -(amount - parameter)
-  end
-
-end

data/app/models/rails_trade/promote_charge/minus_promote_charge.rb

@@ -1,11 +0,0 @@
-module RailsTrade::PromoteCharge::MinusPromoteCharge
-  extend ActiveSupport::Concern
-  included do
-    validates :parameter, numericality: { less_than_or_equal_to: 0 }
-  end
-  
-  def final_price(amount = nil)
-    - parameter.abs.round(2)
-  end
-
-end

data/app/models/rails_trade/promote_charge/plus_promote_charge.rb

@@ -1,7 +0,0 @@
-module RailsTrade::PromoteCharge::PlusPromoteCharge
-
-  def final_price(amount)
-    base_price + (amount * parameter).round(2)
-  end
-
-end

data/app/models/rails_trade/promote_charge.rb

@@ -1,84 +0,0 @@
-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
-
-    def max_step
-      0.1.to_d.power(self.columns_hash['max'].scale)
-    end
-
-    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

data/app/models/rails_trade/promote_extra.rb

@@ -1,13 +0,0 @@
-module RailsTrade::PromoteExtra
-  extend ActiveSupport::Concern
-  included do
-    attribute :extra_name, :string
-    attribute :column_name, :string
-    
-    belongs_to :promote
-    
-    validates :extra_name, uniqueness: { scope: :promote_id }
-  end
-  
-  
-end

data/app/models/rails_trade/promote_good.rb

@@ -1,22 +0,0 @@
-module RailsTrade::PromoteGood
-  extend ActiveSupport::Concern
-  
-  included do
-    attribute :status, :string, default: 'available'
-
-    belongs_to :promote
-    belongs_to :good, polymorphic: true, optional: true
-    has_many :promote_buyers, dependent: :delete_all
-    
-    scope :valid, -> { where(status: ['default', 'available']) }
-    
-    enum status: {
-      default: 'default',  # 默认直接添加的服务，不可取消
-      available: 'available',  # 可选
-      unavailable: 'unavailable'  # 不可选
-    }
-    
-    validates :promote_id, uniqueness: { scope: [:good_type, :good_id] }
-  end
-
-end

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

@@ -1,33 +0,0 @@
-module RailsTrade::Refund::AlipayRefund
-  
-  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/refund/bank_refund.rb

@@ -1,5 +0,0 @@
-module RailsTrade::Refund::BankRefund
-
-
-
-end

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

@@ -1,5 +0,0 @@
-module RailsTrade::Refund::HandRefund
-
-
-
-end

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

@@ -1,32 +0,0 @@
-module RailsTrade::Refund::PaypalRefund
-
-  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/refund/stripe_refund.rb

@@ -1,26 +0,0 @@
-module RailsTrade::Refund::StripeRefund
-
-  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