rails_trade 0.0.2 → 0.0.3

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

@@ -0,0 +1,30 @@
+module Trade
+  module Model::PromoteCart
+    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 :cart
+      belongs_to :promote_good, optional: 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
+end

data/app/models/trade/model/promote_charge/discount_promote_charge.rb

@@ -0,0 +1,19 @@
+# 折扣价格
+module Trade
+  module Model::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
+end

data/app/models/trade/model/promote_charge/final_promote_charge.rb

@@ -0,0 +1,11 @@
+# 一口价
+module Trade
+  module Model::PromoteCharge::FinalPromoteCharge
+
+    # 返回原价与一口价之间的差，负数。
+    def final_price(amount)
+      -(amount - parameter)
+    end
+
+  end
+end

data/app/models/trade/model/promote_charge/minus_promote_charge.rb

@@ -0,0 +1,20 @@
+# 满减/ 抵扣券
+module Trade
+  module Model::PromoteCharge::MinusPromoteCharge
+    extend ActiveSupport::Concern
+
+    included do
+      validates :parameter, numericality: { less_than_or_equal_to: 0 }
+    end
+
+    # 如果抵扣券金额大于总额，则为0
+    def final_price(amount)
+      if parameter.abs >= amount
+        - amount
+      else
+        - parameter.abs
+      end
+    end
+
+  end
+end

data/app/models/trade/model/promote_charge/plus_promote_charge.rb

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

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

@@ -0,0 +1,86 @@
+module Trade
+  module Model::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 || columns_hash['min'].limit || 2)
+      end
+
+      def max_step
+        0.1.to_d.power(self.columns_hash['max'].scale || columns_hash['max'].limit || 2)
+      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
+end

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

@@ -0,0 +1,16 @@
+module Trade
+  module Model::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
+end

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

@@ -0,0 +1,28 @@
+module Trade
+  module Model::PromoteGood
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :status, :string, default: 'available'
+      attribute :effect_at, :datetime
+      attribute :expire_at, :datetime
+
+      belongs_to :promote
+      belongs_to :good, polymorphic: true, optional: true
+      has_many :promote_buyers, dependent: :delete_all
+
+      scope :verified, -> { where(status: ['default', 'available']) }
+      scope :valid, -> { t = Time.current; verified.default_where('effect_at-lte': t, 'expire_at-gte': t) }
+
+      enum status: {
+        default: 'default',  # 默认直接添加的服务，不可取消
+        available: 'available',  # 可选
+        unavailable: 'unavailable',  # 不可选
+        specific: 'specific'  # 特定的？
+      }
+
+      validates :promote_id, uniqueness: { scope: [:good_type, :good_id] }
+    end
+
+  end
+end

data/app/models/trade/model/refund/alipay_refund.rb

@@ -0,0 +1,29 @@
+# 支付宝批次号只能当天有效
+module Trade
+  module Model::Refund::AlipayRefund
+
+    def do_refund(params = {})
+      return unless can_refund?
+
+      refund_params = {
+        out_trade_no: order.uuid,
+        refund_amount: self.total_amount.to_s,
+        out_request_no: self.refund_uuid
+      }
+
+      refund_res = Alipay::Service.trade_refund(refund_params)
+      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'
+      else
+        self.reason = "code: #{refund['code']}, msg: #{refund['msg']}"
+        self.state = 'failed'
+      end
+
+      refund
+    end
+
+  end
+end

data/app/models/trade/model/refund/bank_refund.rb

@@ -0,0 +1,4 @@
+module Trade
+  module Model::Refund::BankRefund
+  end
+end

data/app/models/trade/model/refund/card_refund.rb

@@ -0,0 +1,45 @@
+module Trade
+  module Model::Refund::CardRefund
+    extend ActiveSupport::Concern
+
+    included do
+      belongs_to :card
+      has_one :card_log, ->(o){ where(card_id: o.card_id) }, as: :source
+
+      before_validation :sync_card, if: -> { payment.card_id != card_id }
+      after_save :sync_amount, if: -> { completed? && (state_before_last_save == 'init' || saved_change_to_total_amount?) }
+      after_create_commit :sync_card_log
+    end
+
+    def do_refund(params = {})
+      self.state = 'completed'
+    end
+
+    def sync_card
+      self.card = payment.card
+      self.total_amount = payment.total_amount
+    end
+
+    def sync_amount
+      card.reload
+      card.expense_amount -= self.total_amount
+      computed = card.compute_expense_amount
+      if card.expense_amount == computed
+        card.save!
+      else
+        card.errors.add :amount, "  #{card.expense_amount} Not Equal Computed #{computed}"
+        logger.error "#{self.class.name}/Card: #{card.error_text}"
+        raise ActiveRecord::RecordInvalid.new(card)
+      end
+    end
+
+    def sync_card_log
+      cl = self.card_log || self.build_card_log
+      cl.title = card.card_uuid
+      cl.tag_str = '虚拟币退款'
+      cl.amount = self.total_amount
+      cl.save
+    end
+
+  end
+end

data/app/models/trade/model/refund/hand_refund.rb

@@ -0,0 +1,9 @@
+module Trade
+  module Model::Refund::HandRefund
+
+    def do_refund(params = {})
+
+    end
+
+  end
+end

data/app/models/trade/model/refund/paypal_refund.rb

@@ -0,0 +1,27 @@
+module Trade
+  module Model::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)
+
+      if result.success?
+        self.state = 'completed'
+      elsif result.error
+        self.reason = result.error['message']
+        self.state = 'failed'
+      end
+
+      result
+    end
+
+  end
+end

data/app/models/trade/model/refund/stripe_refund.rb

@@ -0,0 +1,20 @@
+module Trade
+  module Model::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)
+      self.refund_uuid = refund.id
+
+      if refund.status == 'succeeded'
+        self.state = 'completed'
+      else
+        self.state = 'failed'
+      end
+
+      refund
+    end
+
+  end
+end

data/app/models/trade/model/refund/wxpay_refund.rb

@@ -0,0 +1,74 @@
+# 微信是同一个批次号未退款成功可重复申请
+module Trade
+  module Model::Refund::WxpayRefund
+
+    def transaction_id
+      refunded_payment&.payment_uuid
+    end
+
+    def out_trade_no
+      self.origin&.payment_entity_no
+    end
+
+    def do_refund(**params)
+      app = Wechat::WechatApp.find_by(mch_id: payment.seller_identifier)
+      _params = {
+        out_refund_no: self.refund_uuid,
+        amount: {
+          total: (payment.total_amount * 100).to_i,
+          refund: (total_amount * 100).to_i,
+          currency: 'CNY'
+        },
+        transaction_id: self.payment.payment_uuid
+      }
+      options = {
+        mchid: app.mch_id,
+        serial_no: app.serial_no
+        #apiclient_cert: OpenSSL::X509::Certificate.new(app.apiclient_cert),
+        #apiclient_key: OpenSSL::PKey::RSA.new(app.apiclient_key)
+      }
+
+      begin
+        result = WxPay::Api.invoke_refund(_params, options)
+      rescue StandardError => e
+        result = {}
+        result['return_code'] = e.message.truncate(225)
+      ensure
+        store_refund_result(result)
+      end
+
+      self
+    end
+
+    def store_refund_result(result = {})
+      if ['PROCESSING', 'SUCCESS'].include? result['status']
+        self.state = 'completed'
+        self.refunded_at = result['success_time']
+      else
+        self.state = 'failed'
+        self.comment = result['return_code']
+      end
+    end
+
+    def refund_query
+      return if state == 'completed'
+      app = Wechat::WechatApp.find_by(mch_id: payment.seller_identifier)
+      params = {
+        out_refund_no: self.refund_uuid
+      }
+      options = {
+        mchid: app.mch_id,
+        serial_no: app.serial_no
+      }
+
+      result = WxPay::Api.refund_query(params, options)
+      store_refund_result(result)
+    end
+
+    def refund_query!
+      refund_query
+      save
+    end
+
+  end
+end