rails_trade 0.0.2 → 0.0.3

data/app/models/rails_trade/good.rb

@@ -1,71 +0,0 @@
-module RailsTrade::Good
-  extend ActiveSupport::Concern
-  
-  included do
-    attribute :name, :string
-    attribute :sku, :string, default: -> { SecureRandom.hex }
-    attribute :price, :decimal, default: 0
-    attribute :advance_price, :decimal, default: 0
-    attribute :extra, :json, default: {}
-    attribute :unit, :string
-    attribute :quantity, :decimal, default: 0
-    attribute :unified_quantity, :decimal, default: 0
-    
-    has_many :trade_items, as: :trade, autosave: true, dependent: :destroy
-    has_many :orders, through: :trade_items, source: :trade
-
-    has_many :promote_goods, as: :good
-  end
-  
-  def final_price
-    compute_order_amount
-    #self.retail_price + self.promote_price
-  end
-
-  def valid_promote_goods
-    PromoteGood.valid.where(good_type: self.class.base_class.name, good_id: [nil, self.id]).where.not(promote_id: self.promote_goods.select(:promote_id).unavailable)
-  end
-
-  def default_promote_goods
-    PromoteGood.default.where(good_type: self.class.base_class.name, good_id: [nil, self.id])
-  end
-
-  def generate_order!(buyer: nil, cart: nil, maintain_id: nil, **params)
-    o = generate_order(buyer: buyer, cart: cart, maintain_id: maintain_id, **params)
-    o.check_state
-    o.save!
-    o
-  end
-
-  def generate_order(buyer: nil, cart: nil, maintain_id: nil, **params)
-    if buyer
-      o = buyer.orders.build
-    elsif cart
-      o = cart.orders.build
-    else
-      raise 'please assign buyer or cart'
-    end
-    
-    o.organ_id = self.organ_id if self.respond_to?(:organ_id)
-    if o.respond_to?(:maintain_id)
-      o.maintain_id = maintain_id
-      o.organ_id ||= o.maintain&.organ_id
-    end
-    
-    ti = o.trade_items.build(good: self)
-    ti.assign_attributes params.slice(:number)
-    ti.init_amount
-    ti.compute_promote
-    ti.sum_amount
-
-    o.assign_attributes params.slice(:extra, :currency)
-    o.compute_promote
-    o.compute_amount
-    o
-  end
-
-  def order_done
-    puts 'Should realize in good entity'
-  end
-
-end

data/app/models/rails_trade/order.rb

@@ -1,98 +0,0 @@
-module RailsTrade::Order
-  extend ActiveSupport::Concern
-  include RailsTrade::Ordering::Payment
-  include RailsTrade::Ordering::Refund
-
-  included do
-    attribute :uuid, :string
-    attribute :state, :string
-    attribute :item_amount, :decimal, precision: 10, scale: 2
-    attribute :overall_additional_amount, :decimal, precision: 10, scale: 2
-    attribute :overall_reduced_amount, :decimal, precision: 10, scale: 2
-    attribute :amount, :decimal, precision: 10, scale: 2
-    attribute :received_amount, :decimal, precision: 10, scale: 2
-    attribute :payment_id, :integer, comment: 'for paypal'
-    attribute :myself, :boolean, default: true
-    attribute :note, :string, limit: 4096
-    attribute :expire_at, :datetime
-    attribute :payment_status, :string, default: 'unpaid', index: true
-    attribute :received_amount, :decimal, default: 0
-    attribute :expire_at, :datetime, default: -> { Time.current + RailsTrade.config.expire_after }
-    attribute :extra, :json, default: {}
-    attribute :currency, :string, default: RailsTrade.config.default_currency
-    attribute :trade_items_count, :integer, default: 0
-    attribute :lock_version, :integer
-
-    belongs_to :organ, optional: true
-    belongs_to :cart, optional: true
-    belongs_to :user, optional: true
-    belongs_to :payment_strategy, optional: true
-    has_many :payment_orders, dependent: :destroy
-    has_many :payments, through: :payment_orders, inverse_of: :orders
-    has_many :refunds, dependent: :nullify, inverse_of: :order
-
-    scope :credited, -> { where(payment_strategy_id: PaymentStrategy.where.not(period: 0).pluck(:id)) }
-    scope :to_pay, -> { where(payment_status: ['unpaid', 'part_paid']) }
-
-    enum payment_status: {
-      unpaid: 'unpaid',
-      part_paid: 'part_paid',
-      all_paid: 'all_paid',
-      refunding: 'refunding',
-      refunded: 'refunded',
-      denied: 'denied'
-    }
-
-    after_initialize if: :new_record? do
-      if cart
-        self.user_id = cart.user_id
-        self.payment_strategy_id = cart.payment_strategy_id
-      end
-    end
-    before_validation do
-      self.uuid ||= UidHelper.nsec_uuid('OD')
-    end
-    after_save :sync_from_cart, if: -> { saved_change_to_cart_id? && cart }
-    after_create_commit :confirm_ordered!
-
-    delegate :url_helpers, to: 'Rails.application.routes'
-  end
-
-  def subject
-    trade_items.map { |oi| oi.good&.name || 'Goods' }.join(', ')
-  end
-
-  def user_name
-    user&.name.presence || "#{user&.id}"
-  end
-
-  def amount_money
-    amounto_money(self.currency)
-  end
-
-  def compute_promote
-  end
-
-  def metering_attributes
-    attributes.slice 'quantity', 'amount'
-  end
-
-  def sync_from_cart
-    cart.trade_items.checked.default_where(myself: myself).update_all(trade_type: self.class.name, trade_id: self.id)
-    cart.trade_promotes.update_all(trade_type: self.class.name, trade_id: self.id)
-
-    self.compute_amount
-    self.save
-  end
-
-  def confirm_ordered!
-    self.trade_items.each(&:confirm_ordered!)
-  end
-
-  def compute_received_amount
-    _received_amount = self.payment_orders.where(state: 'confirmed').sum(:check_amount)
-    _refund_amount = self.refunds.where.not(state: 'failed').sum(:total_amount)
-    _received_amount - _refund_amount
-  end
-
-end

data/app/models/rails_trade/ordering/payment.rb

@@ -1,113 +0,0 @@
-# payment_id
-# payment_type
-# amount
-# received_amount
-module RailsTrade::Ordering::Payment
-
-  def can_pay?
-    self.payment_status != 'all_paid'
-  end
-
-  def unreceived_amount
-    self.amount.to_d - self.received_amount.to_d
-  end
-
-  def init_received_amount
-    self.payment_orders.confirmed.sum(:check_amount)
-  end
-
-  def pending_payments
-    Payment.where.not(id: self.payment_orders.pluck(:payment_id)).where(payment_method_id: self.buyer.payment_method_ids, state: ['init', 'part_checked'])
-  end
-
-  def exists_payments
-    Payment.where.not(id: self.payment_orders.pluck(:payment_id)).exists?(payment_method_id: self.buyer.payment_method_ids, state: ['init', 'part_checked'])
-  end
-
-  def confirm_paid!
-    self.expire_at = nil
-    self.trade_items.each(&:confirm_paid!)
-    sent_notice
-  end
-
-  def confirm_part_paid!
-    self.expire_at = nil
-    self.trade_items.each(&:confirm_part_paid!)
-  end
-
-  def change_to_paid!(type:, payment_uuid:, params: {})
-    payment = self.payments.find_by(type: type, payment_uuid: payment_uuid)
-
-    if payment
-      self.check_state!
-      payment
-    else
-      payment = self.payments.build(type: type, payment_uuid: payment_uuid)
-      payment.assign_detail params
-
-      payment_order = self.payment_orders.find { |i| i.id.nil? }
-      payment_order.check_amount = payment.total_amount
-
-      begin
-        self.class.transaction do
-          payment_order.confirm!
-          payment.save!
-          self.save!
-        end
-      rescue ActiveRecord::RecordInvalid => e
-        payment.errors.add :base, 'can not save'
-        logger.error "#{payment.errors.full_messages.join(', ')}"
-        raise e
-      end
-      payment
-    end
-  end
-
-  def sent_notice
-    return unless self.user
-    PaidChannel.broadcast_to(
-      self.user_id,
-      link: url_helpers.my_order_url(id),
-      )
-  end
-
-  def payment_result(payment_kind: payment_type)
-    if self.payment_status == 'all_paid'
-      return self
-    end
-
-    if self.amount == 0
-      self.received_amount = self.amount
-      self.check_state!
-    end
-
-    if payment_kind.present?
-      begin
-        self.send payment_kind.to_s + '_result'
-      rescue NoMethodError
-        self
-      end
-    end
-
-    self
-  end
-
-  def check_state
-    if self.received_amount.to_d >= self.amount
-      self.payment_status = 'all_paid'
-      self.confirm_paid!
-    elsif self.received_amount.to_d > 0 && self.received_amount.to_d < self.amount
-      self.payment_status = 'part_paid'
-      self.confirm_part_paid!
-    elsif self.received_amount.to_d <= 0
-      self.payment_status = 'unpaid'
-    end
-  end
-
-  def check_state!
-    self.received_amount = init_received_amount
-    self.check_state
-    self.save!
-  end
-
-end

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

@@ -1,34 +0,0 @@
-module RailsTrade::Ordering::Refund
-
-  def apply_for_refund(payment_id = nil)
-    if ['unpaid', 'refunding', 'refunded'].include? self.payment_status
-      return
-    end
-
-    if payment_id
-      payments = self.payments.where(id: payment_id)
-    else
-      payments = self.payments
-    end
-
-    payments.each do |payment|
-      refund = self.refunds.build(payment_id: payment.id)
-      refund.type = payment.type.sub(/Payment/, '') + 'Refund'
-      refund.total_amount = payment.total_amount
-      refund.currency = payment.currency
-      self.received_amount -= payment.total_amount
-    end
-
-    self.payment_status = 'refunding'
-
-    self.class.transaction do
-      self.confirm_refund!
-      self.save!
-    end
-  end
-
-  def confirm_refund!
-    self.trade_items.each(&:confirm_refund!)
-  end
-
-end

data/app/models/rails_trade/payment/alipay_payment.rb

@@ -1,15 +0,0 @@
-module RailsTrade::Payment::AlipayPayment
-
-  def assign_detail(params)
-    self.buyer_identifier = params['buyer_login_id']
-    self.pay_status = params['trade_status']
-
-    self.total_amount = params['total_amount']
-    self.income_amount = params['receipt_amount']
-
-    self.notified_at = params['send_pay_date']
-
-    self.seller_identifier = params['store_id'].to_s + params['terminal_id'].to_s
-  end
-
-end

data/app/models/rails_trade/payment/apple_payment.rb

@@ -1,7 +0,0 @@
-module RailsTrade::Payment::ApplePayment
-
-  def assign_detail(params)
-    self.total_amount = params[:total_amount]
-  end
-
-end

data/app/models/rails_trade/payment/bank_payment.rb

@@ -1,13 +0,0 @@
-module RailsTrade::Payment::BankPayment
-  #validates :buyer_name, presence: true
-  #validates :buyer_identifier, presence: true
-
-  def assign_detail(params)
-    self.notified_at = Time.now
-    self.total_amount = params[:total_amount]
-    self.order_uuid = order.uuid
-    self.buyer_email = order.contact&.email
-    self.buyer_identifier = order.contact_id
-  end
-
-end

data/app/models/rails_trade/payment/hand_payment.rb

@@ -1,8 +0,0 @@
-module RailsTrade::Payment::HandPayment
-  
-  def assign_detail(params)
-    self.notified_at = Time.now
-    self.total_amount = params[:total_amount]
-  end
-
-end

data/app/models/rails_trade/payment/paypal_payment.rb

@@ -1,8 +0,0 @@
-module RailsTrade::Payment::PaypalPayment
-
-  def assign_detail(trans)
-    self.payment_uuid = trans.related_resources[0].sale.id
-    self.total_amount = trans.amount.total
-  end
-
-end

data/app/models/rails_trade/payment/stripe_payment.rb

@@ -1,9 +0,0 @@
-module RailsTrade::Payment::StripePayment
-
-  def assign_detail(charge)
-    self.payment_uuid = charge.id
-    self.total_amount = Money.new(charge.amount, self.currency).to_d
-    self.currency = charge.currency.upcase
-  end
-
-end

data/app/models/rails_trade/payment/wxpay_payment.rb

@@ -1,13 +0,0 @@
-module RailsTrade::Payment::WxpayPayment
-
-  def assign_detail(params)
-    self.notified_at = params['time_end']
-    self.payment_uuid = params['transaction_id']
-    self.pay_status = params['result_code']
-    self.seller_identifier = params['mch_id']
-    self.buyer_identifier = params['openid']
-    self.total_amount = params['total_fee'].to_i / 100.0
-    self.fee_amount = (self.total_amount * 0.60 / 100).round(2)
-  end
-
-end

data/app/models/rails_trade/payment.rb

@@ -1,134 +0,0 @@
-module RailsTrade::Payment
-  extend ActiveSupport::Concern
-  included do
-    attribute :type, :string, default: 'HandPayment'
-    attribute :payment_uuid, :string
-    attribute :state, :string, default: 'init', index: true
-    attribute :pay_status, :string
-    attribute :currency, :string, default: RailsTrade.config.default_currency
-    attribute :adjust_amount, :decimal, precision: 10, scale: 2, default: 0
-    attribute :total_amount, :decimal, precision: 10, scale: 2, default: 0
-    attribute :fee_amount, :decimal, precision: 10, scale: 2, default: 0
-    attribute :checked_amount, :decimal, precision: 10, scale: 2, default: 0
-    attribute :income_amount, precision: 10, scale: 2
-    attribute :notify_type, :string, limit: 255
-    attribute :notified_at, :datetime
-    attribute :seller_identifier, :string
-    attribute :buyer_identifier, :string
-    attribute :buyer_name, :string
-    attribute :buyer_bank, :string
-    attribute :comment, :string
-    attribute :verified, :boolean, default: true
-    attribute :lock_version, :integer
-
-    belongs_to :organ, optional: true
-    belongs_to :user, optional: true
-    belongs_to :payment_method, optional: true
-    belongs_to :creator, optional: true
-    has_many :payment_orders, inverse_of: :payment, dependent: :destroy
-    has_many :orders, through: :payment_orders, inverse_of: :payments
-
-    default_scope -> { order(created_at: :desc) }
-
-    validates :payment_uuid, presence: true, uniqueness: { scope: :type }
-
-    before_validation do
-      self.payment_uuid = UidHelper.nsec_uuid('PAY') if payment_uuid.blank?
-    end
-    before_save :compute_amount
-    after_create :analyze_payment_method
-
-    has_one_attached :proof
-
-    enum state: {
-      init: 'init',
-      part_checked: 'part_checked',
-      all_checked: 'all_checked',
-      adjust_checked: 'adjust_checked',
-      abusive_checked: 'abusive_checked'
-    }
-  end
-
-  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 - payment_orders.sum(:check_amount)
-  end
-
-  def compute_amount
-    if income_amount.blank? && fee_amount.present?
-      self.income_amount = self.total_amount - self.fee_amount
-    end
-
-    if fee_amount.blank? && income_amount.present?
-      self.fee_amount = self.total_amount - self.income_amount
-    end
-
-    self.check_state
-  end
-
-  def compute_checked_amount
-    self.payment_orders.where(state: :confirmed).sum(:check_amount)
-  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
-      Order.none
-    end
-  end
-
-  def analyze_adjust_amount
-    self.adjust_amount = self.checked_amount.to_d - self.total_amount.to_d
-    self.state = 'all_checked'
-    self.save
-  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 self.checked_amount == self.total_amount
-      self.state = 'all_checked'
-    elsif self.checked_amount == 0
-      self.state = 'init'
-    elsif self.checked_amount < self.total_amount
-      self.state = 'part_checked'
-    elsif self.checked_amount > self.total_amount
-      self.state = 'adjust_checked'
-    else
-      self.state = 'abusive_checked'
-    end
-  end
-
-  def check_state!
-    self.check_state
-    self.save!
-  end
-
-  class_methods do
-
-    def total_amount_step
-      0.1.to_d.power(Payment.columns_hash['total_amount'].scale)
-    end
-
-  end
-
-end