rails_trade 0.0.2 → 0.0.3

data/app/models/rails_trade/payment_method/stripe_method.rb

@@ -1,60 +0,0 @@
-module RailsTrade::PaymentMethod::StripeMethod
-  extend ActiveSupport::Concern
-  included do
-    attr_accessor :token
-    after_destroy_commit :remove
-  end
-  
-  def retrieve
-    customer = Stripe::Customer.retrieve account_num
-    customer_info(customer)
-  end
-
-  def customer_info(customer)
-    card = customer.sources.data[0]
-    return {} unless card
-    {
-      description: customer.description,
-      address_zip: card.address_zip,
-      address_zip_check: card.address_zip_check,
-      brand: card.brand,
-      country: card.country,
-      cvc_check: card.cvc_check,
-      exp_month: card.exp_month,
-      exp_year: card.exp_year,
-      fingerprint: card.fingerprint,
-      funding: card.funding,
-      last4: card.last4
-    }
-  end
-
-  def update_extra
-    self.update extra: retrieve.to_h
-  end
-
-  def remove
-    cu = Stripe::Customer.retrieve account_num
-    cu.delete
-  end
-
-  def detective_save
-    begin
-      customer = Stripe::Customer.create(description: "buyer_id: #{payment_references.map { |i| i.buyer_id }}", source: self.token)
-      self.account_num = customer.id
-      self.extra = self.customer_info(customer)
-    rescue Stripe::StripeError => ex
-      self.errors.add :base, ex.message
-    end
-
-    self.verified = true
-    if self.errors.blank?
-      self.save
-    else
-      false
-    end
-  end
-
-end
-
-
-

data/app/models/rails_trade/payment_method.rb

@@ -1,67 +0,0 @@
-module RailsTrade::PaymentMethod
-  extend ActiveSupport::Concern
-  included do
-    attribute :type, :string
-    attribute :account_name, :string
-    attribute :account_num, :string
-    attribute :bank, :string
-    attribute :verified, :boolean, default: false
-    attribute :myself, :boolean, default: true
-    attribute :extra, :json, default: {}
-    
-    belongs_to :creator, optional: true
-    has_many :payments, dependent: :nullify
-    has_many :payment_references, dependent: :destroy, autosave: true, inverse_of: :payment_method
-    has_many :buyers, through: :payment_references
-  
-    default_scope -> { where(verified: true) }
-  
-    validates :account_num, uniqueness: { scope: [:account_name, :verified] }, if: :verified?
-  end
-  
-  def account_types
-    PaymentReference.pluck(:account_type).uniq
-  end
-
-  def detective_save
-    if detect_repetition
-      self.verified = false
-    else
-      self.verified = true
-    end
-    self.save
-  end
-
-  def detect_repetition
-    if self.persisted?
-      self.class.unscoped.where.not(id: self.id).exists?(account_name: self.account_name, account_num: self.account_num)
-    else
-      self.class.unscoped.exists?(account_name: self.account_name, account_num: self.account_num)
-    end
-  end
-
-  def repeat_results
-    self.class.where.not(id: self.id).where(account_name: self.account_name, account_num: self.account_num)
-  end
-
-  def merge_from(other_id)
-    other = self.class.unscoped.find other_id
-
-    self.class.transaction do
-      other.payment_references.each do |payment_reference|
-        payment_reference.payment_method_id = self.id  # for callback, do not use update
-        payment_reference.save
-      end
-      other.payment_references.reload
-      other.destroy
-    end
-  end
-
-  def kind
-    type.to_s.sub('Method', '').downcase
-  end
-
-end
-
-
-

data/app/models/rails_trade/payment_order.rb

@@ -1,108 +0,0 @@
-module RailsTrade::PaymentOrder
-  extend ActiveSupport::Concern
-  included do
-    attribute :check_amount, :decimal, precision: 10, scale: 2, default: 0
-    attribute :state, :string, default: 'init'
-
-    belongs_to :order, inverse_of: :payment_orders
-    belongs_to :payment, inverse_of: :payment_orders
-    has_one :refund, ->(o){ where(order_id: o.order_id) }, foreign_key: :payment_id, primary_key: :payment_id
-
-    #validate :valid_check_amount
-    validates :order_id, uniqueness: { scope: :payment_id }
-
-    enum state: {
-      init: 'init',
-      confirmed: 'confirmed'
-    }
-    after_save :checked_payment, if: -> { confirmed? && (saved_change_to_state? || saved_change_to_check_amount?) }
-    after_save :unchecked_payment, if: -> { init? && (saved_change_to_state? || saved_change_to_check_amount?) }
-  end
-
-  def valid_check_amount
-    if the_payment_amount > payment.total_amount + payment.adjust_amount
-      self.errors.add(:check_amount, 'Total checked amount greater than payment\'s amount')
-    end
-
-    if the_order_amount > order.amount + order.adjust_amount
-      self.errors.add(:check_amount, 'Total checked amount greater than Order\'s amount')
-    end
-  end
-
-  def checked_payment
-    checked_to_payment
-    checked_to_order
-  end
-
-  def checked_to_payment
-    self.payment
-
-    payment.checked_amount += self.check_amount
-    if payment.checked_amount == payment.compute_checked_amount
-      payment.check_state
-      payment.save!
-    else
-      payment.errors.add :checked_amount, 'check not equal'
-      logger.error "#{self.class.name}/Payment: #{payment.errors.full_messages.join(', ')}"
-      raise ActiveRecord::RecordInvalid.new(payment)
-    end
-  end
-
-  def checked_to_order
-    self.order && order.reload
-
-    order.received_amount += self.check_amount
-    if order.received_amount == order.compute_received_amount
-      order.check_state
-      order.save!
-    else
-      order.errors.add :received_amount, 'check not equal'
-      logger.error "#{self.class.name}/Order: #{order.errors.full_messages.join(', ')}"
-      raise ActiveRecord::RecordInvalid.new(order)
-    end
-  end
-
-  def unchecked_payment
-    unchecked_to_payment
-    unchecked_to_order
-  end
-
-  def unchecked_to_payment
-    self.payment && payment.reload
-
-    payment.checked_amount -= self.check_amount
-    if payment.checked_amount == payment.compute_checked_amount
-      payment.check_state
-      payment.save!
-    else
-      payment.errors.add :checked_amount, 'uncheck not equal'
-      logger.error "#{self.class.name}/Payment: #{payment.errors.full_messages.join(', ')}"
-      raise ActiveRecord::RecordInvalid.new(payment)
-    end
-  end
-
-  def unchecked_to_order
-    self.order && order.reload
-
-    order.received_amount -= self.check_amount
-    if order.received_amount == order.compute_received_amount
-      order.check_state
-      order.save!
-    else
-      order.errors.add :received_amount, 'uncheck not equal'
-      logger.error "#{self.class.name}/Order: #{order.errors.full_messages.join(', ')}"
-      raise ActiveRecord::RecordInvalid.new(order)
-    end
-  end
-
-  def confirm!
-    self.state = 'confirmed'
-    self.save!
-  end
-
-  def revert_confirm!
-    self.state = 'init'
-    self.save!
-  end
-
-end

data/app/models/rails_trade/payment_reference.rb

@@ -1,18 +0,0 @@
-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, buyer_type: self.buyer_type)
-      throw(:abort)
-    end
-  end
-
-end

data/app/models/rails_trade/payment_strategy.rb

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

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

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

@@ -1,18 +0,0 @@
-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_type/paypal.rb

@@ -1,82 +0,0 @@
-module RailsTrade::PaymentType::Paypal
-
-  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 self if self.payment_status == 'all_paid'
-
-    return unless self.payment_id
-    paypal_payment ||= PayPal::SDK::REST::DataTypes::Payment.find(self.payment_id)
-    trans = paypal_payment.transactions[0]
-
-    if paypal_payment.state == 'approved'
-      self.change_to_paid! type: 'PaypalPayment', payment_uuid: trans.related_resources[0].sale.id, params: trans
-    else
-      errors.add :base, paypal_payment.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

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

@@ -1,55 +0,0 @@
-module RailsTrade::PaymentType::Stripe
-
-  def stripe_charge(params = {})
-    if params[:token]
-      TheStripe.stripe_customer(buyer: self.buyer, token: params[:token])
-    end
-
-    if params[:payment_method_id]
-      stripe_payment_method = buyer.payment_methods.where(type: 'StripeMethod', id: params[:payment_method_id]).first
-    else
-      stripe_payment_method = buyer.payment_methods.where(type: 'StripeMethod').first
-    end
-
-    unless stripe_payment_method
-      self.errors.add :base, 'Please add credit card at first.'
-      return self
-    end
-    return self if self.amount <= 0
-
-    begin
-      charge = Stripe::Charge.create(amount: self.amount_money.cents, currency: self.currency, customer: stripe_payment_method.account_num)
-      self.update payment_type: 'stripe', payment_id: charge.id
-      self.stripe_record(charge)
-    rescue Stripe::StripeError, Stripe::CardError => ex
-      self.errors.add :base, ex.message
-    end
-    self
-  end
-
-  def stripe_result
-    return self if self.payment_status == 'all_paid'
-
-    if self.payment_id.present?
-      charge = Stripe::Charge.retrieve(self.payment_id)
-
-      if charge.paid && !charge.refunded
-         self.change_to_paid! type: 'StripePayment', payment_uuid: charge.id, params: charge
-      else
-        errors.add :uuid, 'error'
-      end
-
-    end
-  end
-
-  # execute payment
-  # required:
-  # token
-  def self.stripe_customer(buyer:, **params)
-    payment_method = buyer.payment_methods.build(type: 'StripeMethod')
-    payment_method.token = params[:token]
-    payment_method.detective_save
-    payment_method
-  end
-
-end