rails_trade 0.0.1

data/app/models/rails_trade/order_item.rb

@@ -0,0 +1,88 @@
+class OrderItem < ApplicationRecord
+  belongs_to :order, autosave: true, inverse_of: :order_items
+  belongs_to :cart_item, optional: true, autosave: true
+  belongs_to :good, polymorphic: true, optional: true
+  belongs_to :provider, optional: true
+  has_many :order_promotes, autosave: true
+  has_many :order_serves, autosave: true
+  has_many :serves, through: :order_serves
+
+  composed_of :promote,
+              class_name: 'PromoteFee',
+              mapping: [['good_type', 'good_type'], ['good_id', 'good_id'], ['quantity', 'number']]
+  composed_of :serve,
+              class_name: 'ServeFee',
+              mapping: [['good_type', 'good_type'], ['good_id', 'good_id'], ['quantity', 'number']]
+
+  after_initialize if: :new_record? do |oi|
+    if cart_item
+      self.good_type = cart_item.good_type
+      self.good_id = cart_item.good_id
+      self.number = cart_item.quantity
+      self.pure_price = cart_item.pure_price
+      self.advance_payment = self.good.advance_payment if self.advance_payment.to_f.zero?
+      #self.provider = cart_item.good.provider
+
+      cart_item.serve_charges.each do |serve_charge|
+        op = self.order_serves.build(serve_charge_id: serve_charge.id, serve_id: serve_charge.serve_id, amount: serve_charge.subtotal)
+        op.order = self.order
+      end
+      cart_item.promote.charges.each do |promote_charge|
+        op = self.order_promotes.build(promote_charge_id: promote_charge.id, promote_id: promote_charge.promote_id, amount: promote_charge.subtotal)
+        op.order = self.order
+      end
+      compute_sum
+
+      unless self.amount == cart_item.final_price
+        puts 'amount is wrong'
+      end
+
+      cart_item.status = 'ordered'
+    end
+  end
+  after_update_commit :sync_amount, if: -> { saved_change_to_amount? }
+
+  def sync_amount
+    order.compute_sum
+    order.save
+  end
+
+  def compute_sum
+    self.serve_sum = self.order_serves.sum { |os| os.amount }
+    self.promote_sum = self.order_promotes.sum { |op| op.amount }
+    self.amount = self.pure_price + self.serve_sum + self.promote_sum  # 校验是否等于cart_item.final_price
+  end
+
+  def confirm_ordered!
+    self.good.order_done
+  end
+
+  def confirm_paid!
+
+  end
+
+  def confirm_part_paid!
+
+  end
+
+  def confirm_refund!
+
+  end
+
+end unless RailsTrade.config.disabled_models.include?('OrderItem')
+
+# :cart_item_id, :integer
+# :good_type, :string
+# :good_id, :integer
+# :quantity, :float
+# :unit, :string
+# :number, :integer, limit: 4, default: 1
+# :total_price, :decimal, limit: 24
+# :order_at :datetime
+# :payed_at :datetime
+# :comment, :string
+# :deliver_on, :date
+# #advance_payment, :decimal, precision: 10, scale: 2
+
+
+

data/app/models/rails_trade/order_promote.rb

@@ -0,0 +1,23 @@
+class OrderPromote < ApplicationRecord
+  belongs_to :order, inverse_of: :order_promotes
+  belongs_to :order_item, optional: true
+  belongs_to :promote
+  belongs_to :promote_charge, optional: true
+
+  after_update_commit :sync_amount, if: -> { saved_change_to_amount? }
+
+  def sync_amount
+    if self.order_item_id.nil?
+      order.compute_sum
+      order.save
+    else
+      order_item.compute_sum
+      order_item.save
+    end
+  end
+
+end unless RailsTrade.config.disabled_models.include?('OrderPromtote')
+
+# :order_id, :integer
+# :order_item_id :integer
+

data/app/models/rails_trade/order_serve.rb

@@ -0,0 +1,23 @@
+class OrderServe < ApplicationRecord
+  belongs_to :order, inverse_of: :order_serves
+  belongs_to :order_item, optional: true
+  belongs_to :serve_charge, optional: true
+  belongs_to :serve
+
+  after_update_commit :sync_amount, if: -> { saved_change_to_amount? }
+
+  def sync_amount
+    if self.order_item_id.nil?
+      order.compute_sum
+      order.save
+    else
+      order_item.compute_sum
+      order_item.save
+    end
+  end
+
+end unless RailsTrade.config.disabled_models.include?('OrderServe')
+
+# :order_id, :integer
+# :order_item_id :integer
+

data/app/models/rails_trade/order_shipment.rb

@@ -0,0 +1,10 @@
+class OrderShipment < ApplicationRecord
+  belongs_to :order
+  belongs_to :shipment
+
+
+end unless RailsTrade.config.disabled_models.include?('OrderShipment')
+
+# :order_id, :integer
+# :shipment_id, :integer
+

data/app/models/rails_trade/payment.rb

@@ -0,0 +1,135 @@
+class Payment < ApplicationRecord
+  include Auditable
+
+  attribute :currency, :string, default: 'USD'
+
+  belongs_to :payment_method, optional: true
+  has_many :payment_orders, dependent: :destroy, inverse_of: :payment
+  has_many :orders, through: :payment_orders, inverse_of: :payments
+
+  default_scope -> { order(created_at: :desc) }
+
+  validates :total_amount, numericality: { equal_to: -> (o) { o.income_amount + o.fee_amount } }, if: -> { income_amount.present? && fee_amount.present? && total_amount.present? }
+  validates :adjust_amount, numericality: { less_than: 1, greater_than: -1 }, allow_blank: true
+  validates :payment_uuid, uniqueness: true
+
+  before_save :compute_amount
+  after_create :analyze_payment_method
+
+  #has_one_attached :proof
+
+  after_initialize if: :new_record? do |o|
+    self.payment_uuid ||= UidHelper.nsec_uuid('PAY')
+  end
+
+  enum state: [
+    :init,
+    :part_checked,
+    :all_checked,
+    :abusive_checked
+  ]
+
+  def analyze_payment_method
+    if self.buyer_name.present? || self.buyer_identifier.present?
+      pm = PaymentMethod.find_or_initialize_by(account_name: self.buyer_name.to_s, account_num: self.buyer_identifier.to_s)
+      pm.bank = self.buyer_bank
+      self.payment_method = pm
+
+      pm.save
+      self.save
+    end
+  end
+
+  def unchecked_amount
+    total_amount.to_d - pending_checked_amount.to_d
+  end
+
+  def pending_checked_amount
+    PaymentOrder.where(payment_id: self.id).sum(:check_amount)
+  end
+
+  def compute_amount
+    if total_amount.blank? && fee_amount.present? && income_amount.present?
+      self.total_amount = self.fee_amount + self.income_amount
+    end
+
+    if income_amount.blank? && total_amount.present? && fee_amount.present?
+      self.income_amount = self.total_amount - self.fee_amount
+    end
+
+    if fee_amount.blank? && total_amount.present? && income_amount.present?
+      self.fee_amount = self.total_amount - self.income_amount
+    end
+    self.check_state
+  end
+
+  def pending_orders
+    if self.payment_method
+      buyer_ids = self.payment_method.payment_references.pluck(:buyer_id)
+      Order.where.not(id: self.payment_orders.pluck(:order_id)).where(buyer_id: buyer_ids, payment_status: ['unpaid', 'part_paid'], state: 'active')
+    else
+      []
+    end
+  end
+
+  def analyze_adjust_amount
+    self.adjust_amount = init_adjust_amount
+    self.state = 'all_checked'
+    self.save
+  end
+
+  def init_adjust_amount
+    self.checked_amount.to_d - self.total_amount.to_d
+  end
+
+  def check_order(order_id)
+    order = Order.find order_id
+    payment_order = self.payment_orders.build(order_id: order.id)
+    payment_order.check_amount = order.unreceived_amount
+    payment_order.save
+
+    payment_order
+  end
+
+  def check_state
+    if checked_amount.to_d >= total_amount
+      self.state = 'all_checked'
+      self.adjust_amount = self.checked_amount.to_d - self.total_amount
+    elsif self.checked_amount.to_d > 0 && self.checked_amount.to_d < self.total_amount
+      self.state = 'part_checked'
+    elsif self.checked_amount.to_d == 0
+      self.state = 'init'
+    else
+      self.state = 'abusive_checked'
+    end
+  end
+
+  def check_state!
+    self.check_state
+    self.save!
+  end
+
+  def self.total_amount_step
+    0.1.to_d.power(Payment.columns_hash['total_amount'].scale)
+  end
+
+end unless RailsTrade.config.disabled_models.include?('Payment')
+
+#  :id, :integer, limit: 4, null: false
+#  :type, :string, limit: 255
+#  :total_amount, :decimal, precision: 10, scale: 2
+#  :order_amount, :decimal, precision: 10, scale: 2
+#  :fee_amount, :decimal, precision: 10, scale: 2
+#  :payment_uuid, :string, limit: 255
+#  :notify_type, :string, limit: 255
+#  :notified_at, :datetime, precision: 0
+#  :pay_status, :string, limit: 255
+#  :buyer_email, :string, limit: 255
+#  :sign, :string, limit: 255
+#  :seller_identifier, :string, limit: 255
+#  :buyer_identifier, :string, limit: 255
+#  :user_id, :integer, limit: 4
+#  :currency, :string, limit: 255
+#  :state, :integer, limit: 4, default: 0
+#  :created_at, :datetime, precision: 0, null: false
+#  :updated_at, :datetime, precision: 0, null: false

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

@@ -0,0 +1,8 @@
+module PaymentInterfaceBase
+  extend ActiveSupport::Concern
+  
+  def amount_money
+    self.amount.to_money(self.currency)
+  end
+
+end

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

@@ -0,0 +1,49 @@
+module TheAlipay
+  extend ActiveSupport::Concern
+
+  included do
+  end
+
+  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
+
+  # 3 step: check result
+  def alipay_result
+    result = Alipay2::Service.trade_query out_trade_no: self.uuid
+    result = JSON.parse(result)
+    result = result['alipay_trade_query_response']
+    alipay_record(result)
+  end
+
+  def alipay_record(result)
+    if result['trade_status'] == 'TRADE_SUCCESS'
+      alipay = AlipayPayment.find_by(payment_uuid: result['trade_no'])
+      return alipay if alipay
+
+      alipay = AlipayPayment.new
+      alipay.payment_uuid = result['trade_no']
+      alipay.buyer_identifier = result['buyer_user_id']
+      alipay.total_amount = result['total_amount']
+      alipay.income_amount = result['receipt_amount']
+      alipay.notified_at = result['send_pay_date']
+
+      payment_order = alipay.payment_orders.build(order_id: self.id, check_amount: alipay.total_amount)
+
+      Payment.transaction do
+        payment_order.confirm!
+        alipay.save!
+      end
+      alipay
+    else
+      errors.add :uuid, result['msg']
+    end
+  end
+
+end

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

@@ -0,0 +1,103 @@
+module ThePaypal
+  extend ActiveSupport::Concern
+
+  included do
+    delegate :url_helpers, to: 'Rails.application.routes'
+  end
+
+  def paypal_prepay
+    paypal_payment = PayPal::SDK::REST::DataTypes::Payment.new(paypal_params)
+
+    result = paypal_payment.create
+    if result
+      self.update(payment_id: paypal_payment.id)
+    else
+      self.errors.add :payment_id, paypal_payment.error.inspect
+    end
+    paypal_payment.links.find{ |v| v.rel == 'approval_url' }.href
+  end
+
+  def paypal_execute(params)
+    return unless self.payment_id
+    paypal_payment = PayPal::SDK::REST::DataTypes::Payment.find(self.payment_id)
+    paypal_payment.execute(payer_id: params[:PayerID])
+
+    paypal_record(paypal_payment)
+  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
+
+      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)
+
+      Payment.transaction do
+        payment_order.confirm!
+        paypal.save!
+      end
+      paypal
+    else
+      errors.add :uuid, record.error.inspect
+    end
+  end
+
+  def paypal_params
+    {
+      intent: 'sale',
+      payer: {
+        payment_method: 'paypal'
+      },
+      redirect_urls: {
+        return_url: url_helpers.paypal_execute_my_order_url(self.id),
+        cancel_url: url_helpers.cancel_my_order_url(self.id)
+      },
+      transactions: {
+        item_list: {
+          items: paypal_items_params
+        },
+        amount: {
+          total: self.unreceived_amount,
+          currency: self.currency.upcase
+        },
+        description: ''
+      }
+    }
+  end
+
+  def paypal_items_params
+    items = order_items.map do |item|
+      {
+        name: item.good.name,
+        sku: item.good.sku,
+        price: item.good.price.to_money.exchange_to(self.currency).to_s,
+        currency: self.currency.upcase,
+        quantity: item.number
+      }
+    end
+    serves = order_serves.map do |item|
+      {
+        name: item.serve.name,
+        sku: item.serve.id,
+        price: item.price.to_money.exchange_to(self.currency).to_s,
+        currency: self.currency.upcase,
+        quantity: 1
+      }
+    end
+    items + serves
+  end
+
+end