rails_trade 0.0.1 → 0.0.2

data/app/models/rails_trade/address.rb

@@ -1,14 +0,0 @@
-class Address < ApplicationRecord
-  belongs_to :area, optional: true
-
-  enum kind: {
-    transport: 'transport',
-    forwarder: 'forwarder',
-    invoice: 'invoice'
-  }
-
-  after_initialize if: :new_record? do |t|
-    self.buyer_id = self.user&.buyer_id
-  end
-
-end unless RailsTrade.config.disabled_models.include?('Address')

data/app/models/rails_trade/area.rb

@@ -1,65 +0,0 @@
-class Area < ApplicationRecord
-  has_many :provinces, -> { where(city: '').where.not(province: '') }, class_name: 'Area', primary_key: :nation, foreign_key: :nation, dependent: :destroy
-  has_many :cities, -> { where.not(city: '') }, class_name: 'Area', primary_key: :province, foreign_key: :province, dependent: :destroy
-
-  scope :all_provinces, -> { where(city: '').where.not(province: '')}
-
-  scope :popular, -> { where(popular: true) }
-
-  scope :nations, ->(region_name){ where(region: region_name).group(:nation).pluck(:nation, :nation) }
-  scope :provinces, ->(nation_name){ select(:province).distinct.where(nation: nation_name) }
-  scope :cities, ->(province_name){ select(:city).distinct.where(province: province_name) }
-
-  default_scope -> { where(published: true) }
-
-  after_commit :update_timestamp, :delete_cache, on: [:create, :update]
-
-  def self.list
-    Rails.cache.fetch('areas/list') do
-      nations.includes(provinces: :cities).map do |nation|
-        {
-          id: nation.id,
-          name: nation.nation,
-          provinces: nation.provinces.map do |province|
-            {
-              id: province.id,
-              name: province.province,
-              cities: province.cities.map do |city|
-                { id: city.id, name: city.city }
-              end
-            }
-          end
-        }
-      end
-    end
-  end
-
-  def self.timestamp
-    Rails.cache.fetch('areas/timestamp') do
-      order(updated_at: :desc).last.updated_at.to_i
-    end
-  end
-
-  def self.all_nations
-    Rails.cache.fetch('areas/all_nations') do
-      select(:nation).distinct.pluck(:nation)
-    end
-  end
-
-  private
-  def delete_cache
-    ['areas/list', 'areas/popular', 'areas/all_nations'].each do |c|
-      Rails.cache.delete(c)
-    end
-  end
-
-  def update_timestamp
-    t = self.updated_at.to_i
-    Rails.cache.write('areas/timestamp', t)
-  end
-
-end unless RailsTrade.config.disabled_models.include?('Area')
-# :region
-# :nation
-# :province
-# :city

data/app/models/rails_trade/cart_item.rb

@@ -1,185 +0,0 @@
-class CartItem < ApplicationRecord
-  belongs_to :good, polymorphic: true, optional: true
-  has_many :cart_item_serves, -> { includes(:serve) }, dependent: :destroy
-  has_many :order_items, dependent: :nullify
-
-  validates :user_id, presence: true, if: -> { session_id.blank? }
-  validates :session_id, presence: true, if: -> { user_id.blank?  }
-  scope :valid, -> { where(status: 'pending', myself: true) }
-  scope :checked, -> { where(status: 'pending', checked: true) }
-
-  serialize :extra, Hash
-
-  enum status: {
-    init: 'init',
-    pending: 'pending',
-    ordered: 'ordered',
-    deleted: 'deleted'
-  }
-
-  composed_of :serve,
-              class_name: 'ServeFee',
-              mapping: [['good_type', 'good_type'], ['good_id', 'good_id'], ['quantity', 'number'], ['buyer_id', 'buyer_id'], ['extra', 'extra']],
-              constructor: Proc.new { |type, id, num, buyer, o_extra| ServeFee.new(type, id, num, buyer, self.extra.merge(Hash(o_extra))) }
-
-  composed_of :promote,
-              class_name: 'PromoteFee',
-              mapping: [['good_type', 'good_type'], ['good_id', 'good_id'], ['quantity', 'number'], ['buyer_id', 'buyer_id']],
-              constructor: Proc.new { |type, id, num, buyer| PromoteFee.new(type, id, num, buyer) }
-
-  after_initialize if: :new_record? do |t|
-    self.status = 'init' if self.status.blank?
-    self.buyer_id = self.user&.buyer_id if self.buyer_id.blank?
-    self.quantity = 1 if self.quantity.to_i < 1
-  end
-
-  def total_quantity
-    good.unified_quantity.to_d * self.quantity
-  end
-
-  # 零售价
-  def retail_price
-    self.good.retail_price * self.quantity
-  end
-
-  def discount_price
-    bulk_price - retail_price
-  end
-
-  # 商品原价
-  def pure_price
-    good.price.to_d * quantity
-  end
-
-  # 附加服务价格汇总
-  def serve_price
-    serve_charges.sum { |i| i.subtotal }
-  end
-
-  # 促销价格
-  def reduced_price
-    self.promote.subtotal
-  end
-
-  # 批发价
-  def bulk_price
-    pure_price + serve_price
-  end
-
-  def final_price
-    self.bulk_price + self.reduced_price
-  end
-
-  def total_serve_price
-    total_serve_charges.sum { |i| i.subtotal }
-  end
-
-  def total_promote_price
-    total.promote_charges.sum { |i| i.subtotal }
-  end
-
-  def estimate_price
-    final_price + total_serve_price + total_promote_price
-  end
-
-  def get_charge(serve)
-    charge = self.serve.get_charge(serve)
-    cart_item_serve = cart_item_serves.find { |cart_item_serve| cart_item_serve.serve_id == charge.serve_id  }
-    if cart_item_serve.persisted?
-      charge.cart_item_serve = cart_item_serve
-      charge.subtotal = cart_item_serve.price
-    end
-    charge
-  end
-
-  def serve_charges
-    charges = []
-    serve.charges.each do |charge|
-      cart_item_serve = cart_item_serves.find { |cart_item_serve| cart_item_serve.serve_id == charge.serve_id  }
-      if cart_item_serve
-        charge.cart_item_serve = cart_item_serve
-        charge.subtotal = cart_item_serve.price
-      end
-      charges << charge
-    end
-
-    cart_item_serves.where(scope: 'single').where.not(serve_id: serve.charges.map(&:serve_id)).each do |cart_item_serve|
-      charge = self.serve.get_charge(cart_item_serve.serve)
-      charge.cart_item_serve = cart_item_serve
-      charge.subtotal = cart_item_serve.price
-      charges << charge
-    end
-    charges
-  end
-
-  def total_serve_charges
-    charges = []
-    total.serve_charges.each do |charge|
-      cart_item_serve = cart_item_serves.find { |cart_item_serve| cart_item_serve.serve_id == charge.serve_id  }
-      if cart_item_serve
-        charge.cart_item_serve = cart_item_serve
-        charge.subtotal = cart_item_serve.price
-      end
-      charges << charge
-    end
-
-    cart_item_serves.where(scope: 'total').where.not(serve_id: total.serve_charges.map(&:serve_id)).each do |cart_item_serve|
-      charge = self.serve.get_charge(cart_item_serve.serve)
-      charge.cart_item_serve = cart_item_serve
-      charge.subtotal = cart_item_serve.price
-      charges << charge
-    end
-    charges
-  end
-
-  def total_promote_charges
-    total.promote_charges
-  end
-
-  def for_select_serves
-    @for_sales = Serve.for_sale.where.not(id: cart_item_serves.map(&:serve_id).uniq)
-    @for_sales.map do |serve|
-      self.serve.get_charge(serve)
-    end.compact
-  end
-
-  def same_cart_items
-    if self.user_id
-      CartItem.where(buyer_id: self.user_id).valid
-    else
-      CartItem.where(session_id: self.session_id).valid
-    end
-  end
-
-  def total
-    relation = CartItem.where(id: self.id)
-    SummaryService.new(relation, buyer_id: self.buyer_id, extra: self.extra)
-  end
-
-  def self.checked_items(user_id: nil, buyer_id: nil, session_id: nil, myself: nil, extra: self.extra)
-    if user_id
-      @checked_items = CartItem.default_where(user_id: user_id, myself: myself).pending.checked
-      buyer_id = @checked_items.first&.buyer_id
-      puts "-----> Checked User: #{user_id}"
-    elsif buyer_id
-      @checked_items = CartItem.default_where(buyer_id: buyer_id, myself: myself).pending.checked
-      puts "-----> Checked Buyer: #{buyer_id}"
-    elsif session_id
-      @checked_items = CartItem.default_where(session_id: session_id, myself: myself).pending.checked
-      puts "-----> Checked Session: #{session_id}"
-    else
-      @checked_items = CartItem.none
-      puts "-----> Checked None!"
-    end
-    SummaryService.new(@checked_items, buyer_id: buyer_id, extra: extra)
-  end
-
-  def self.extra
-    {}
-  end
-
-  def self.good_types
-    CartItem.select(:good_type).distinct.pluck(:good_type)
-  end
-
-end unless RailsTrade.config.disabled_models.include?('CartItem')

data/app/models/rails_trade/cart_item_serve.rb

@@ -1,16 +0,0 @@
-class CartItemServe < ApplicationRecord
-  belongs_to :cart_item, touch: true
-  belongs_to :serve
-
-  validates :serve_id, uniqueness: { scope: [:cart_item_id] }
-  validates :price, presence: true
-
-  after_initialize if: :new_record? do |t|
-    self.scope = self.serve.scope
-  end
-
-end unless RailsTrade.config.disabled_models.include?('CartItemServe')
-
-
-# :cart_item_id, :integer
-# :serve_id, :integer

data/app/models/rails_trade/concerns/good_able.rb

@@ -1,63 +0,0 @@
-module GoodAble
-  extend ActiveSupport::Concern
-
-  included do
-    attribute :name, :string
-    attribute :import_price, :decimal, default: 0
-    attribute :profit_price, :decimal, default: 0
-    attribute :price, :decimal, default: 0
-    attribute :advance_payment, :decimal, default: 0
-    attribute :sku, :string, default: 'item'
-    attribute :currency, :string
-
-    has_many :cart_items, as: :good, autosave: true, dependent: :destroy
-    has_many :order_items, as: :good, dependent: :nullify
-    has_many :orders, through: :order_items
-    has_many :promote_goods, as: :good
-    has_many :promotes, through: :promote_goods
-
-    composed_of :serve,
-                class_name: 'ServeFee',
-                mapping: ['id', 'good_id'],
-                constructor: Proc.new { |id| ServeFee.new(self.name, id, 1, nil, self.extra) }
-    composed_of :promote,
-                class_name: 'PromoteFee',
-                mapping: [['id', 'good_id']],
-                constructor: Proc.new { |id| PromoteFee.new(self.name, id) }
-    before_save :sync_price, if: -> { import_price_changed? || profit_price_changed? }
-
-    def self.extra
-      {}
-    end
-  end
-
-  def extra
-    {}
-  end
-
-  def retail_price
-    self.price.to_d + self.serve.subtotal
-  end
-
-  def final_price
-    self.retail_price + self.promote.subtotal
-  end
-
-  def order_done
-    puts 'Should realize in good entity'
-  end
-
-  def all_serves
-    Serve.default_where('serve_goods.good_type': self.class.name, 'serve_goods.good_id': [nil, self.id])
-  end
-
-  def all_promotes
-    Promote.default_where('promote_goods.good_type': self.class.name, 'promote_goods.good_id': [nil, self.id])
-  end
-
-  private
-  def sync_price
-    self.price = self.import_price.to_d + self.profit_price.to_d
-  end
-
-end

data/app/models/rails_trade/concerns/order_able.rb

@@ -1,48 +0,0 @@
-module OrderAble
-  extend ActiveSupport::Concern
-  include GoodAble
-
-  included do
-    has_one :order_item, as: :good, dependent: :nullify
-    has_one :order, through: :order_item
-  end
-
-  def update_order
-    order_item.update amount: self.price
-  end
-
-  def get_order
-    return @order if @order
-    @order = self.order || generate_order(self.user, { number: 1 })
-  end
-
-  def generate_order(user, params = {})
-    o = user.orders.build
-    o.buyer_id = user.buyer_id if user.buyer_id && self.respond_to?(:buyer_id)
-    o.currency = self.currency
-
-    oi = o.order_items.build
-    oi.good = self
-    if params[:number].to_i > 0
-      oi.number = params[:number]
-    else
-      oi.number = 1
-    end
-
-    if params[:amount]
-      oi.amount = params[:amount]
-    else
-      oi.amount = oi.number * self.price.to_d
-    end
-
-    o.amount = oi.amount
-
-    self.class.transaction do
-      o.check_state
-      o.save!
-      oi.save!
-    end
-    o
-  end
-
-end

data/app/models/rails_trade/concerns/promote_fee.rb

@@ -1,54 +0,0 @@
-# cart_item
-# good
-class PromoteFee
-  attr_reader :good, :number, :buyer,
-              :extra, :charges
-
-  def initialize(good_type, good_id, number = 1, buyer_id = nil, extra = {})
-    @good = good_type.constantize.unscoped.find good_id
-    @number = number
-    @buyer = RailsTrade.buyer_class.find(buyer_id) if buyer_id
-    @extra = extra
-    verbose_fee
-  end
-
-  def verbose_fee
-    @charges = []
-
-    Promote.single.overall.each do |promote|
-      charge = get_charge(promote)
-      @charges << charge
-    end
-
-    if buyer
-      buyer.promotes.single.each do |promote|
-        charge = get_charge(promote)
-        @charges << charge
-      end
-    end
-
-    @charges
-  end
-
-  def pure_price
-    good.price * number
-  end
-
-  def retail_price
-    good.retail_price * number
-  end
-
-  def subtotal
-    @subtotal ||= self.charges.map(&:subtotal).sum
-  end
-
-  def get_charge(promote)
-    if promote.is_a?(AmountPromote)
-      charge = promote.compute_price(retail_price)
-    else
-      charge = promote.compute_price(retail_price)
-    end
-    charge
-  end
-
-end