Module: BlsmVdCore

Defined in:: lib/blsm-vd-core.rb,
lib/blsm-vd-core/version.rb,
lib/blsm-vd-core/model/user.rb,
lib/blsm-vd-core/model/order.rb,
lib/blsm-vd-core/model/product.rb,
lib/blsm-vd-core/model/rc_user.rb,
lib/blsm-vd-core/model/setting.rb,
lib/blsm-vd-core/model/ubox_vm.rb,
lib/blsm-vd-core/model/clearing.rb,
lib/blsm-vd-core/model/line_item.rb,
lib/blsm-vd-core/model/vd_mp_msg.rb,
lib/blsm-vd-core/model/vd_wx_pay.rb,
lib/blsm-vd-core/model/application.rb,
lib/blsm-vd-core/model/user_spread.rb,
lib/blsm-vd-core/model/vd_info_sec.rb,
lib/blsm-vd-core/model/encrypted_id.rb,
lib/blsm-vd-core/model/product_prop.rb,
lib/blsm-vd-core/model/vd_free_post.rb,
lib/blsm-vd-core/model/vd_user_info.rb,
lib/blsm-vd-core/model/vd_week_sale.rb,
lib/blsm-vd-core/model/active_record.rb,
lib/blsm-vd-core/model/clearing_item.rb,
lib/blsm-vd-core/model/shippingorder.rb,
lib/blsm-vd-core/model/vd_user_score.rb,
lib/blsm-vd-core/model/recharge_spread.rb,
lib/blsm-vd-core/model/vd_invite_reward.rb,
lib/blsm-vd-core/model/vd_rc_msg_notify.rb,
lib/blsm-vd-core/model/vd_week_order_sale.rb,
lib/blsm-vd-core/model/vd_purchase_fee_log.rb

Defined Under Namespace

Modules: EncryptedId Classes: Application, BaseRecord, Clearing, ClearingItem, LineItem, Order, Product, ProductProp, RcUser, RechargeSpread, Setting, Shippingorder, UboxVm, User, UserSpread, VdFreePost, VdInfoSec, VdInviteReward, VdMpMsg, VdPurchaseFeeLog, VdRcMsgNotify, VdUserInfo, VdUserScore, VdWeekOrderSale, VdWeekSale, VdWxPay

Constant Summary collapse

ERROR_CODES = 错误代码

{
    0 => {code: 0, msg: '什么都没发生'},

    401 => {code: 401, msg: '没有权限'},
    4010 => {code: 4010, msg: '安全校验未通过'},

    404 => {code: 404, msg: '订单未找到'},
    4042 => {code: 4042, msg: '结算项未找到'},
    4043 => {code: 4043, msg: '空订单'},
    4044 => {code: 4044, msg: '订单没有所属微店主'},
    4045 => {code: 4045, msg: '用户不存在'},
    4046 => {code: 4046, msg: 'setting值不存在'},
    4047 => {code: 4047, msg: 'setting规则不匹配'},
    4048 => {code: 4048, msg: 'setting值为空'},

    200 => {code: 200, msg: '成功'}
}

VERSION =

"1.0.4"

Class Attribute Summary collapse

.db_config ⇒ Object

Returns the value of attribute db_config.

Class Method Summary collapse

.create_clearing_item(order_id, force = false) ⇒ Object

创建(更新)结算项调用此方法，只会创建一个对应的结算项，如果之前有结算项，会直接更新相应的结算项 ==== Parameters * order_id - 订单id * force - 是否强制创建结算项.
.current_week_period_str ⇒ Object

这一周.
.last_week_period_str ⇒ Object

上一周.
.load_config ⇒ Object
.on_clearing_item_cash_back(clearing_item_id) ⇒ Object

结算项变为物流返款时调用此方法.
.on_order_canceled(seller_id, order_id) ⇒ Object

【積分消耗】商品售卖出去什么时候调用此方法合适？当订单的状态变更为‘已取消’时微店主的积分会根据商品总的供货价的订单取消，微店主会被扣直接的订单供货价 * SCORES[:SALE_OUT_DIRECT] 积分微店主所属的队长（直接上级）被扣订单供货价 * SCORES[:SALE_OUT_INDIRECT] 积分 ==== Parameters * seller_id - 销售员的id * order_id - 订单id.
.on_order_export_to_erp(order_id) ⇒ Object

订单被导入到erp时判断订单是否包含顺丰包邮商品，并根据此创建包邮券.
.on_order_sale_out(seller_id, order_id) ⇒ Object

【积分获取】商品售卖出去什么时候调用此方法合适？当订单的状态变更为‘客户签收，订单完成’时，标明商品已经被售出微店主的积分会根据商品总的供货价的商品卖出，微店主会获取直接的订单供货价 * SCORES[:SALE_OUT_DIRECT] 积分微店主所属的队长（直接上级）获取订单供货价 * SCORES[:SALE_OUT_INDIRECT] 积分 ==== Parameters * seller_id - 销售员的id * order_id - 订单id.
.on_order_sign_fail(seller_id, order_id) ⇒ Object

什么时候调用此方法合适？当订单的状态变更为‘拒签’时 ==== Parameters * seller_id - 销售员的id * order_id - 订单id.
.on_order_signed(order_id, sign_type) ⇒ Object

物流返款 ==== Parameters * order_id - 订单id * sign_type - 签收状态：ENUM(‘sign_ok’,‘sign_fail’).
.on_order_state_change(order_id) ⇒ Object

当订单状态发生变化时，调用此方法包含：订单被发出去 order_sale_out 创建结算项 create_clearing_item ==== Parameters * order_id - 订单id.
.send_cash_back_notify(order_id, wx_app_id = nil) ⇒ Object

发送物流返款通知.
.sq_invite_on_order_delivering(seller_id, order_id) ⇒ Object

订单发货以后(通过首趣码邀请的回调).
.sq_invite_on_order_rejecting(seller_id, order_id) ⇒ Object

订单拒签以后(通过首趣码邀请的回调).

Class Attribute Details

.db_config ⇒ `Object`

Returns the value of attribute db_config.



59
60
61

# File 'lib/blsm-vd-core.rb', line 59

def db_config
  @db_config
end

Class Method Details

.create_clearing_item(order_id, force = false) ⇒ `Object`

创建(更新)结算项调用此方法，只会创建一个对应的结算项，如果之前有结算项，会直接更新相应的结算项

Parameters

order_id - 订单id
force - 是否强制创建结算项

# File 'lib/blsm-vd-core.rb', line 233

def create_clearing_item(order_id, force=false)
  order = Order.where(id: order_id).first
  line_items = order.line_items if order
  user = order.application.user if order && order.application

  #数据校验
  return ERROR_CODES[404] unless order
  return ERROR_CODES[4043] unless line_items && !line_items.empty?
  return ERROR_CODES[4044] unless user

  user_info = user.create_vd_user_info

  #没有对应的结算项
  if order.clearing_items.empty?
    #线上订单(等待配货时创建结算项) 线下订单(客户签收时创建结算项)
    if (!order.ubox_order? && order.state=='等待配货') || (order.ubox_order? && order.state=='客户签收，订单完成') || force
      data = {}
      data[:order_id] = order.id
      data[:order_amount] = order.total_fee
      data[:earn_amount] = order.jm_profit
      data[:user_id] = user.id
      data[:item_type] ='default'
      data[:rate_of_profit] = order.ubox_order? ? 0.25 : user_info.profit_rate
      data[:state] = 'WAIT_TO_SURE'

      if order.pay_off_line?
        data[:pay_type] = 'CODPAY'
      else
        data[:pay_type] = 'ZXZF'
        data[:real_amount] = order.total_fee
      end

      ClearingItem.new(data).save


      leader = User.where("id in(select supervisor_id from vd_user_infos where user_id=#{user.id})").first
      leader_info = leader.create_vd_user_info if leader


      #订单确认提醒（黑带）
      leader_change = order.get_vd_score(leader_info.vd_role) if leader_info

      if leader && leader_info && !order.ubox_order?
        content = "首趣黑带#{leader.username}，你好：你的队员【#{user.username}】已成功确认订单，"

        #客户端通知
        if leader.rc_user
          VdRcMsgNotify.create_distribute_notify(leader.id, order.id, content, leader_change)
        end

        #微信通知
        if leader.openid
          distribute_leader_notify = {touser: leader.openid,
                                      order_id: Order.encrypt(Order.encrypted_id_key, order.id.to_s),
                                      score_change: leader_change,
                                      money_change: (leader_change*VdUserScore::SCORES[:SCORE_TO_MONEY]).round(2),
                                      content: content
          }
          BlsmMpWx.create_msg(nil, leader.openid, distribute_leader_notify, 'distribute')
        end
      end

      return ERROR_CODES[200]
    end
  end

  #有对应的结算项（逐个去更新）
  order.clearing_items.each { |item|
    unless item.clearing
      data = {}
      data[:order_id] = order.id
      data[:order_amount] = order.total_fee
      data[:earn_amount] = order.jm_profit
      data[:rate_of_profit] = order.ubox_order? ? order.ubox_vm.settlement_rate : user_info.profit_rate
      if order.pay_off_line?
        data[:pay_type] = 'CODPAY'
      else
        data[:pay_type] = 'ZXZF'
        data[:real_amount] = order.total_fee
      end
      item.update_attributes(data)
      return ERROR_CODES[200]
    end
  }

  ERROR_CODES[0]

end

.current_week_period_str ⇒ `Object`

这一周

# File 'lib/blsm-vd-core.rb', line 816

def current_week_period_str
  t = Time.now
  "#{t.strftime('%Y')}-#{t.at_beginning_of_week.strftime("%m%d")}-#{t.at_end_of_week.strftime("%m%d")}"
end

.last_week_period_str ⇒ `Object`

上一周

# File 'lib/blsm-vd-core.rb', line 810

def last_week_period_str
  t = Time.now - 7.day
  "#{t.strftime('%Y')}-#{t.at_beginning_of_week.strftime("%m%d")}-#{t.at_end_of_week.strftime("%m%d")}"
end

.load_config ⇒ `Object`

# File 'lib/blsm-vd-core/model/active_record.rb', line 3

def self.load_config
  config_path = Rails.root ? File.join(Rails.root, "config", "database.yml") : './config/database.yml'
  File.open(config_path).inject('') { |text, line| text+line }
end

.on_clearing_item_cash_back(clearing_item_id) ⇒ `Object`

结算项变为物流返款时调用此方法

# File 'lib/blsm-vd-core.rb', line 710

def on_clearing_item_cash_back(clearing_item_id)
  clearing_item = ClearingItem.where(id: clearing_item_id).first
  return ERROR_CODES[0] if !clearing_item || clearing_item.state!='CASH_BACK' || clearing_item.earn_amount.to_f < 0 || clearing_item.created_at.to_s < '2017-02-27'
  order = clearing_item.order
  return ERROR_CODES[0] if !order || order.ubox_order?
  invitee = clearing_item.user
  return ERROR_CODES[0] unless invitee
  inviter = invitee.sq_inviter

  return ERROR_CODES[4010] if VdInviteReward.where(order_id: order.id).first

  vd_transaction = "clearing_item_cash_back_#{clearing_item_id}"
  return ERROR_CODES[4010] if VdInfoSec.dangerous?(vd_transaction)

  reward = 0
  LineItem.where(:order_id => order.id).each do |line_item|
    product_prop = line_item.product_prop
    reward += line_item.quantity*product_prop.inviter_reward if product_prop && line_item.sale_price!=0
  end

  if reward > 0
    week = current_week_period_str #物流返款按自然周返款统计奖金金额
    VdInviteReward.create({inviter_id: inviter.id, invitee_id: invitee.id, order_id: order.id, reward: reward, week: week})
  end

  #安全库录入信息
  VdInfoSec.committed(vd_transaction)

  ERROR_CODES[200]
end

.on_order_canceled(seller_id, order_id) ⇒ `Object`

【積分消耗】商品售卖出去什么时候调用此方法合适？当订单的状态变更为‘已取消’时微店主的积分会根据商品总的供货价的订单取消，微店主会被扣直接的订单供货价 * SCORES[:SALE_OUT_DIRECT] 积分

微店主所属的队长（直接上级）被扣 订单供货价 * +SCORES[:SALE_OUT_INDIRECT]+ 积分

Parameters

seller_id - 销售员的id
order_id - 订单id

# File 'lib/blsm-vd-core.rb', line 596

def on_order_canceled(seller_id, order_id)
  seller = User.where(id: seller_id).first
  # leader = User.where("id in(select supervisor_id from vd_user_infos where user_id=#{seller_id})").first
  order = Order.where(id: order_id).first

  return ERROR_CODES[4045] unless seller
  return ERROR_CODES[401] if !order || !order.application


  return ERROR_CODES[0] unless order.clearing_items

  #删除结算项
  order.clearing_items.each { |item|
    item.destroy unless item.state == 'CASH_BACK'
  }

  #安全校验(是否曾经被售出过)
  score_type_str = "order_sale_out_#{seller_id}_#{order_id}"
  sold_out = VdInfoSec.dangerous?(score_type_str)
  return ERROR_CODES[200] unless sold_out

  #安全校验(是否曾经此订单被取消，并且扣取积分)
  vd_transaction = "order_sale_out_#{seller_id}_#{order_id}_then_cancel"
  danger = VdInfoSec.dangerous?(vd_transaction)
  return danger if danger

  #卖家和团队领导的信息
  # seller_info = seller.create_vd_user_info
  # leader_info = leader && leader.is_vd_black? ? leader.create_vd_user_info : nil

  content = "您的订单(编号#{order.number})客户先签收后又取消。"
  VdUserScore.where(score_type: score_type_str).each do |score|
    score_change = -score.score
    if score.user && !order.ubox_order? && score_change!=0
      score.user.create_vd_user_info.change_score(score_change)

      content = "您的队员#{seller.username}的订单(订单编号#{order.number})客户先签收后又取消。" if seller.id != score.user.id
      notify = {touser: score.user.openid, change: score_change, total: score.user.create_vd_user_info.score, content: "变动原因：#{content}"}

      #变动通知
      BlsmMpWx.create_msg(nil, score.user.openid, notify, 'score_change')
      VdRcMsgNotify.create_order_sign_fail_notify(score.user_id, score_change, order.number, content)

      #积分历史
      VdUserScore.create({
                             user_id: score.user_id,
                             score: score_change,
                             notes: content,
                             score_type: vd_transaction
                         })
    end
  end


  #安全库录入信息
  VdInfoSec.committed(vd_transaction)

  ERROR_CODES[200]

end

.on_order_export_to_erp(order_id) ⇒ `Object`

订单被导入到erp时判断订单是否包含顺丰包邮商品，并根据此创建包邮券

# File 'lib/blsm-vd-core.rb', line 135

def on_order_export_to_erp(order_id)
  order = Order.where(id: order_id).first
  settings = Setting.where(name: 'vd_free_post_products').first
  seller = order.application.user if order && order.application

  #数据校验
  return ERROR_CODES[404] unless order
  return ERROR_CODES[4043] unless order.line_items
  return ERROR_CODES[4046] unless settings
  return ERROR_CODES[4045] unless seller

  product_ids = settings.value.to_s.split('|').map(&:to_i)

  return ERROR_CODES[4048] if product_ids.size==0

  product_count = order.line_items.inject(0) { |s, item| s+= product_ids.include?(item.product_id) ? 1*item.quantity : 0; s }
  return ERROR_CODES[4047] unless product_count >0

  #安全校验
  vd_transaction = "order_export_to_erp_handle_#{order_id}"
  danger = VdInfoSec.dangerous?(vd_transaction)
  return danger if danger
  product_count.times do
    VdFreePost.create({user_id: seller.id})
  end
  content = "恭喜您获得#{product_count}次免补差价发顺丰资格，点击查看 http://w.url.cn/s/AQsuRun\n有效期限：#{Setting.where(name: 'vd_free_post_default_expire').pluck(:value)[0]}到期"
  VdMpMsg.create!({
                      app_id: BlsmMpWx.APP_ID,
                      openid: seller.openid,
                      content: content,
                      msg_name: "custom",
                      template_msg: false,
                      status: 'none'
                  }) if seller.openid

  VdInfoSec.committed(vd_transaction)
  ERROR_CODES[200]
end

.on_order_sale_out(seller_id, order_id) ⇒ `Object`

【积分获取】商品售卖出去什么时候调用此方法合适？当订单的状态变更为‘客户签收，订单完成’时，标明商品已经被售出微店主的积分会根据商品总的供货价的商品卖出，微店主会获取直接的订单供货价 * SCORES[:SALE_OUT_DIRECT] 积分

微店主所属的队长（直接上级）获取 订单供货价 * +SCORES[:SALE_OUT_INDIRECT]+ 积分

Parameters

seller_id - 销售员的id
order_id - 订单id

# File 'lib/blsm-vd-core.rb', line 330

def on_order_sale_out(seller_id, order_id)
  seller = User.where(id: seller_id).first
  return ERROR_CODES[4045] unless seller

  leader = User.where("id in(select supervisor_id from vd_user_infos where user_id=#{seller_id})").first
  order = Order.where(id: order_id).first

  return ERROR_CODES[401] if !order || !order.application || !(order.application.user_id==seller_id)

  #安全校验
  vd_transaction = "order_sale_out_#{seller_id}_#{order_id}"
  danger = VdInfoSec.dangerous?(vd_transaction)
  return danger if danger

  #卖家和团队领导的信息
  seller_info = seller.create_vd_user_info
  leader_info = leader && leader.is_vd_black? ? leader.create_vd_user_info : nil

  #供货价总和
  franchise_sum = order.franchise_sum

  #积分获取
  # seller_change = order.get_vd_score(seller_info.vd_role)
  seller_change = 0
  if leader_info
    leader_change = order.get_vd_score(leader_info.vd_role)
    # - 卖家是黑带，但是从属于某个黑带名下
    if seller_info.is_black?
      seller_change = (order.get_vd_score(seller_info.vd_role))*0.7
      leader_change = (order.get_vd_score(seller_info.vd_role))*0.3
      # - 卖家所属的黑带，是某个黑带的附属黑带
    elsif leader_info.supervisor_slave && leader_info.supervisor
      org_leader = leader_info.supervisor
      org_leader_info = org_leader.create_vd_user_info
      leader_change = order.get_vd_score(leader_info.vd_role)*0.7
      org_leader_change = order.get_vd_score(org_leader_info.vd_role)*0.3
    end
    #卖家是黑带
  else
    seller_change = order.get_vd_score(seller_info.vd_role) if seller_info.is_black?
  end

  # 卖家信息变动
  if seller_change!=0 && !order.ubox_order?
    seller_info.change_score(seller_change)

    #融云推送
    if seller.rc_user
      VdRcMsgNotify.create_score_change_notify(seller.id, "您好，订单#{order.number}已成功签收，分销#{franchise_sum}元", seller_change, '积分', seller_info.score)
    end

    #微信通知
    if seller.openid
      seller_notify = {touser: seller.openid, change: seller_change, total: seller_info.score, content: "您好，订单#{order.number}已成功签收，分销#{franchise_sum}元"}
      BlsmMpWx.create_msg(nil, seller.openid, seller_notify, 'score_change')
    end
  end

  VdUserScore.create({
                         user_id: seller_id,
                         score: seller_change,
                         notes: "订单#{order.number}已#{order.ubox_order? ? '出货成功' : '成功签收'}，分销#{franchise_sum}元",
                         score_type: vd_transaction
                     }) if !order.ubox_order?

  #黑带信息变动
  if leader && leader_info && leader_change && leader_change!=0 && !order.ubox_order?

    leader_info.change_score(leader_change)

    #融云推送
    if leader.rc_user
      VdRcMsgNotify.create_score_change_notify(leader.id,
                                               "首趣黑带#{leader.username}，你好，你的队员【#{seller.username}】订单#{order.number}已成功签收，分销#{franchise_sum}元",
                                               leader_change, '积分', leader_info.score)
    end

    #微信通知
    if leader.openid
      leader_notify = {touser: leader.openid, change: leader_change, total: leader_info.score, content: "首趣黑带#{leader.username}，你好，你的队员【#{seller.username}】订单#{order.number}已成功签收，分销#{franchise_sum}元"}
      BlsmMpWx.create_msg(nil, leader.openid, leader_notify, 'score_change')
    end

    VdUserScore.create({
                           user_id: leader.id,
                           score: leader_change,
                           notes: "队员【#{seller.username}】订单#{order.number}已成功签收，分销#{franchise_sum}元",
                           score_type: vd_transaction
                       })
  end

  #原始黑带信息变动
  if org_leader && org_leader_info && org_leader_change && org_leader_change!=0 && !order.ubox_order?
    org_leader_info.change_score(org_leader_change)

    #融云推送
    if org_leader.rc_user
      VdRcMsgNotify.create_score_change_notify(org_leader.id,
                                               "首趣黑带#{org_leader.username}，你好，你的附属黑带【#{leader.username}】的队员【#{seller.username}】订单#{order.number}已成功签收，分销#{franchise_sum}元",
                                               org_leader_change, '积分',
                                               org_leader_info.score)
    end

    #微信通知
    if org_leader.openid
      org_leader_notify = {touser: org_leader.openid, change: org_leader_change, total: org_leader_info.score,
                           content: "首趣黑带#{org_leader.username}，你好，你的附属黑带【#{leader.username}】的队员【#{seller.username}】订单#{order.number}已成功签收，分销#{franchise_sum}元"}
      BlsmMpWx.create_msg(nil, org_leader.openid, org_leader_notify, 'score_change')
    end

    VdUserScore.create({
                           user_id: org_leader.id,
                           score: org_leader_change,
                           notes: "下属黑带【#{leader.username}】的队员【#{seller.username}】订单#{order.number}已成功签收，分销#{franchise_sum}元",
                           score_type: vd_transaction
                       })
  end
  #店主销售额、分销额增加
  VdUserInfo.update_counters(seller_info.id, :sale_sum => order.total_fee.to_f)
  VdUserInfo.update_counters(seller_info.id, :distribute_sum => order.franchise_sum.to_f)

  #分销额增加,更新未发出货物的(state=CREATE)分成比率
  seller.clearing_items.where(:state => "WAIT_TO_SURE").each do |item|
    if item.order.ubox_order?
      item.update_attributes({:rate_of_profit => order.ubox_vm.settlement_rate,
                              :earn_amount => item.order.jm_profit})
    else
      item.update_attributes({:rate_of_profit => seller_info.profit_rate,
                              :earn_amount => item.order.jm_profit})
    end
  end

  #订单签收,加粉充值自动增加10元
  fans_rewards = Setting.vd_order_sign_fans_rewards
  if fans_rewards && fans_rewards[:order_money]>0 && fans_rewards[:reward_money]>0 && (order.shipping_charge+order.item_total)>= fans_rewards[:order_money]

    user_spread = UserSpread.where(user_id: seller.id).first
    if user_spread
      UserSpread.update_counters(user_spread.id, :amount => fans_rewards[:reward_money])
      RechargeSpread.create({amount: fans_rewards[:reward_money], user_spread_id: user_spread.id, r_type: 1, admin_id: 3, notes: "订单#{order.id}签收奖励"})

      puts "seller:#{seller},rc_user:#{seller.rc_user}"

      #融云推送
      if seller.rc_user
        VdRcMsgNotify.create_order_sign_fans_notify(seller.id,
                                                    fans_rewards[:reward_money],
                                                    order.number,
                                                    "尊敬的店主#{seller.username}，您好，您的订单#{order.number}已成功签收，首趣奖励您粉丝推广费#{fans_rewards[:reward_money]}元")
      end
    end

  end


  #防拒签通知
  if seller.rc_user
    VdRcMsgNotify.create_order_finish_notify(seller.username)
  end

  # # 包邮券返款
  # if order.vd_free_post
  #   ClearingItem.create({
  #                           state: 'CASH_BACK',
  #                           pay_type: "ZXZF",
  #                           user_id: seller.id,
  #                           order_id: -14,
  #                           rate_of_profit: 1,
  #                           earn_amount: order.shipping_charge
  #                       })
  # end

  #供货全返还
  if order.line_items && seller_info.purchase_fee > 0
    franchise_price = order.line_items.inject(0) { |result, item| result+item.franchise_price*item.quantity }
    earn_amount = franchise_price < seller_info.purchase_fee ? franchise_price : seller_info.purchase_fee
    #创建结算项
    ClearingItem.create({
                            state: 'CASH_BACK',
                            pay_type: "ZXZF",
                            user_id: seller.id,
                            order_id: -13,
                            rate_of_profit: 1,
                            earn_amount: earn_amount
                        })
    seller_info.update_attributes(:purchase_fee => (seller_info.purchase_fee - earn_amount))
    #进货费变动记录
    VdPurchaseFeeLog.create(:user_id => seller.id, :purchase_fee => -earn_amount, :description => "订单完成,系统扣除", :admin_user_id => 3)
    #通知用户
    fee_content = "亲爱的店主#{seller.username}：订单已经签收成功，您的优店管家—店主信息—进货费#{franchise_price}元，抵扣#{earn_amount},时间#{Time.now.strftime("%F %H:%M:%S")}"
    if !seller.rc_user.blank?
      #融云通知
      VdRcMsgNotify.create({
                               user_id: 3,
                               to_ids: seller.username,
                               title: "进货费变动提醒",
                               to_type: 'single',
                               msg_type: 'RC:TxtMsg',
                               content: fee_content
                           })
    end
    #微信公众号通知
    VdMpMsg.create!({
                        app_id: BlsmMpWx.APP_ID,
                        openid: seller.openid,
                        content: fee_content,
                        msg_name: "custom",
                        template_msg: false,
                        status: 'none'
                    })
  end

  # 给邀请人奖励
  inviter = User.where(:invication_code => seller.invicated_from).first if seller.invicated_from
  #【旧版邀请】被邀请人,金牌店主以下,渠道邀请,邀请人不为空,一个订单只能有一个结算项
  if inviter && seller_info.created_at.to_s < Setting.old_invite_reward_expired_at && seller_info.distribute_sum < 1500 && seller_info.channel == "market_invite"

    #发送给邀请人微信提醒
    content = "您邀请的店主 #{seller.username}（注册电话号为#{seller.phone}）与#{Time.now.strftime("%Y-%m-%d %H:%M:%S")}成功成交一笔订单，订单金额为#{order.total_fee.to_f}元， 您将同步获取邀请奖励#{(order.total_fee.to_f * 0.1).round(2)}元，特此通知"

    #为邀请人创建,结算项
    ClearingItem.create({
                            state: 'CASH_BACK',
                            pay_type: "ZXZF",
                            user_id: inviter.id,
                            order_id: -11,
                            rate_of_profit: 1,
                            earn_amount: (order.total_fee.to_f * 0.1).round(2)
                        })
    VdMpMsg.create!({
                        app_id: BlsmMpWx.APP_ID,
                        openid: inviter.openid,
                        content: content,
                        msg_name: "custom",
                        template_msg: false,
                        status: 'none'
                    })
    #发送给邀请人融云提醒
    if inviter.rc_user
      VdRcMsgNotify.create({
                               user_id: 3,
                               to_ids: inviter.username,
                               title: "提醒",
                               to_type: 'single',
                               msg_type: 'RC:TxtMsg',
                               content: content
                           })
    end
  end

  #安全库录入信息
  VdInfoSec.committed(vd_transaction)

  ERROR_CODES[200]

end

.on_order_sign_fail(seller_id, order_id) ⇒ `Object`

什么时候调用此方法合适？当订单的状态变更为‘拒签’时

Parameters

seller_id - 销售员的id
order_id - 订单id

# File 'lib/blsm-vd-core.rb', line 661

def on_order_sign_fail(seller_id, order_id)
  seller = User.where(id: seller_id).first
  # leader = User.where("id in(select supervisor_id from vd_user_infos where user_id=#{seller_id})").first
  order = Order.where(id: order_id).first

  return ERROR_CODES[4045] unless seller
  return ERROR_CODES[401] if !order || !order.application || !(order.application.user_id==seller_id)

  #安全校验(是否曾经被售出过)
  score_type_str = "order_sale_out_#{seller_id}_#{order_id}"
  sold_out = VdInfoSec.dangerous?(score_type_str)
  return ERROR_CODES[200] unless sold_out

  #安全校验(是否曾经此订单被取消，并且扣取积分)
  vd_transaction = "order_sale_out_#{seller_id}_#{order_id}_then_sign_fail"
  return ERROR_CODES[200] if VdInfoSec.dangerous?(vd_transaction)

  content = "您的订单(编号#{order.number})客户先签收后又拒签。"
  VdUserScore.where(score_type: score_type_str).each do |score|
    score_change = -score.score
    if score.user && !order.ubox_order?
      score.user.create_vd_user_info.change_score(score_change)

      content = "您的队员#{seller.username}的订单(订单编号#{order.number})客户先签收后又拒签。" if seller.id != score.user.id
      notify = {touser: score.user.openid, change: score_change, total: score.user.create_vd_user_info.score, content: content}

      #变动通知
      BlsmMpWx.create_msg(nil, score.user.openid, notify, 'score_change')
      VdRcMsgNotify.create_order_sign_fail_notify(score.user_id, score_change, order.number, content)

      #积分历史
      VdUserScore.create({
                             user_id: score.user_id,
                             score: score_change,
                             notes: content,
                             score_type: vd_transaction
                         })
    end
  end

  #安全库录入信息
  VdInfoSec.committed(vd_transaction)

  ERROR_CODES[200]

end

.on_order_signed(order_id, sign_type) ⇒ `Object`

物流返款

Parameters

order_id - 订单id
sign_type - 签收状态：ENUM(‘sign_ok’,‘sign_fail’)

# File 'lib/blsm-vd-core.rb', line 178

def on_order_signed(order_id, sign_type)
  order = Order.where(id: order_id).first
  clearing_item = ClearingItem.where(order_id: order.id).first if order
  seller = order.application.user if order && order.application

  #数据校验
  return ERROR_CODES[404] unless order
  return ERROR_CODES[4042] unless clearing_item
  return ERROR_CODES[4045] unless seller
  return ERROR_CODES[0] if sign_type =~ /sign_ok/ && clearing_item.state.to_s =~ /CASH_BACK/

  #安全校验
  vd_transaction = "order_sign_handle_#{order_id}_#{sign_type}"
  danger = VdInfoSec.dangerous?(vd_transaction)
  return danger if danger

  #（物流返款成功，订单完成）
  if sign_type =~ /sign_ok/ && order.pay_off_line?
    note = Order.latest_notes(clearing_item, {username: '首趣'}, '标记物流返款')
    clearing_item.marking_confirm(note)

    VdInfoSec.committed(vd_transaction)
    return ERROR_CODES[200]
  end


  #签收失败（拒签）
  if sign_type =~ /sign_fail/
    VdInfoSec.committed(vd_transaction)
    BlsmVdCore.sq_invite_on_order_rejecting(seller.id, order.id) #拒签
    user = order.application.user if order && order.application
    #拒签删除积分
    on_order_sign_fail(user.id, order_id) if user
    if clearing_item.clearing && clearing_item.clearing.state == "BALANCED"
      i_clearing = clearing_item.clone
      i_clearing.clearing_id = nil
      i_clearing.save
      note = Order.latest_notes(clearing_item, {username: '首趣'}, '标记签收失败')
      i_clearing.marking_refuse(note, clearing_item.possible_profit)
      return ERROR_CODES[200]
    else
      note = Order.latest_notes(clearing_item, {username: '首趣'}, '标记签收失败')
      clearing_item.marking_refuse(note)
      return ERROR_CODES[200]
    end
  end

  ERROR_CODES[0]
end

.on_order_state_change(order_id) ⇒ `Object`

当订单状态发生变化时，调用此方法包含：订单被发出去 order_sale_out

创建结算项  +create_clearing_item+

Parameters

order_id - 订单id

# File 'lib/blsm-vd-core.rb', line 69

def on_order_state_change(order_id)
  order = Order.where(id: order_id).first
  clearing_item = ClearingItem.where(order_id: order.id).first if order

  #数据校验
  return ERROR_CODES[404] unless order

  #等待配货=>创建结算项
  if order.state.to_s.include?('等待配货')
    return create_clearing_item(order_id)
  end


  #订单被取消=>删除结算项(扣除積分)
  if order.state.to_s.include?('订单取消')
    return on_order_canceled(order.application.user_id, order_id) if order.application
  end

  #订单被拒签=>创建shippingorder 拒签的记录
  if order.state.to_s.include?('客户拒签，原件返回')
    shippingorder = Shippingorder.where(:id => order.shippingorder_id).first
    if shippingorder.blank?
      shippingorder = Shippingorder.create(:refuse_at => Time.now)
      order.update_attributes(:shippingorder_id => shippingorder.id)
    else
      shippingorder.update_attributes(:refuse_at => Time.now)
    end
    return
  end

  #在线支付（客户签收，订单完成）=>确认结算项
  if order.state.to_s.include?('客户签收，订单完成')
    create_clearing_item(order_id) if order.ubox_order?
    clearing_item = ClearingItem.where(order_id: order.id).first
    on_order_sale_out(order.application.user_id, order_id) if order.application
    clearing_item.update_attributes({earn_amount: order.jm_profit, state: 'CASH_BACK'}) if clearing_item && order.pay_on_line?
    return ERROR_CODES[200]
  end

  ERROR_CODES[0]
end

.send_cash_back_notify(order_id, wx_app_id = nil) ⇒ `Object`

发送物流返款通知

# File 'lib/blsm-vd-core.rb', line 112

def send_cash_back_notify(order_id, wx_app_id=nil)
  order = Order.where(id: order_id).first
  seller = order.application.user if order && order.application
  #数据校验
  return ERROR_CODES[404] unless order
  return ERROR_CODES[4045] unless seller

  #物流返款通知
  if seller.rc_user
    VdRcMsgNotify.create_cashback_notify(seller.id, order.id)
  end

  if seller.openid
    seller_notify = {touser: seller.openid, order_id: Order.encrypt(Order.encrypted_id_key, order.id.to_s), content: "【物流返款通知】"}
    BlsmMpWx.create_msg(wx_app_id, seller.openid, seller_notify, 'order')
  end

  ERROR_CODES[200]
end

.sq_invite_on_order_delivering(seller_id, order_id) ⇒ `Object`

订单发货以后(通过首趣码邀请的回调)

# File 'lib/blsm-vd-core.rb', line 743

def sq_invite_on_order_delivering(seller_id, order_id)
  seller = User.where(id: seller_id).first
  order = Order.where(id: order_id).first
  clearing_item = ClearingItem.where(order_id: order_id).first

  return ERROR_CODES[4045] unless seller
  return ERROR_CODES[0] if !order || order.ubox_order? || order.shippingorder_id.to_i <= 0
  return ERROR_CODES[0] unless clearing_item

  vd_transaction = "on_order_delivering_#{seller_id}_#{order_id}"
  return ERROR_CODES[4010] if VdInfoSec.dangerous?(vd_transaction)

  wday = Time.now.wday #今天星期几,上一周确认的订单，并且在周二凌晨前发货的订单 上一周销售额  否则算下一周 销售额
  week = wday==1 && clearing_item.created_at < (Time.now - 7.day).at_end_of_week ? last_week_period_str : current_week_period_str


  os = VdWeekOrderSale.where(order_id: order.id).first
  os.update_attributes({user_id: seller.id, week: week, sale_sum: order.total_fee}) if os
  VdWeekOrderSale.create({order_id: order.id, user_id: seller.id, week: week, sale_sum: order.total_fee}) unless os

  ws = VdWeekSale.where(user_id: seller.id, week: week).first
  ws.update_attributes({sale_sum: VdWeekOrderSale.where(week: week, user_id: seller_id).sum(:sale_sum)}) if ws
  VdWeekSale.create({user_id: seller.id, week: week, sale_sum: VdWeekOrderSale.where(week: week, user_id: seller_id).sum(:sale_sum)}) unless ws

  #安全库录入信息
  VdInfoSec.committed(vd_transaction)

  ERROR_CODES[200]
end

.sq_invite_on_order_rejecting(seller_id, order_id) ⇒ `Object`

订单拒签以后(通过首趣码邀请的回调)

# File 'lib/blsm-vd-core.rb', line 774

def sq_invite_on_order_rejecting(seller_id, order_id)
  seller = User.where(id: seller_id).first
  order = Order.where(id: order_id).first
  clearing_item = ClearingItem.where(order_id: order_id).first

  return ERROR_CODES[4045] unless seller
  return ERROR_CODES[0] if !order || order.ubox_order?
  return ERROR_CODES[0] unless clearing_item

  vd_transaction = "on_order_rejecting_#{seller_id}_#{order_id}"
  return ERROR_CODES[4010] if VdInfoSec.dangerous?(vd_transaction)

  wday = Time.now.wday #今天星期几,上一周确认的订单，并且在周二凌晨前拒签的订单 上一周销售额  否则算下一周 销售额
  week = wday==1 && clearing_item.created_at < (Time.now - 7.day).at_end_of_week ? last_week_period_str : current_week_period_str

  os = VdWeekOrderSale.where(order_id: order.id, reject: 0).first #非拒签记录
  os2 = VdWeekOrderSale.where(order_id: order.id, reject: 1).first #拒签记录

  if os || (os2 && os2.sale_sum>0)
    VdWeekOrderSale.create({order_id: order.id, user_id: seller.id, week: week, sale_sum: -order.total_fee, reject: 1})
  elsif !os && !os2
    VdWeekOrderSale.create({order_id: order.id, user_id: seller.id, week: week, sale_sum: 0, reject: 1})
  end

  ws = VdWeekSale.where(user_id: seller.id, week: week).first
  ws.update_attributes({sale_sum: VdWeekOrderSale.where(week: week, user_id: seller_id).sum(:sale_sum)}) if ws
  VdWeekSale.create({user_id: seller.id, week: week, sale_sum: VdWeekOrderSale.where(week: week, user_id: seller_id).sum(:sale_sum)}) unless ws

  #安全库录入信息
  VdInfoSec.committed(vd_transaction)

  ERROR_CODES[200]
end

Module: BlsmVdCore

Defined Under Namespace

Constant Summary collapse

Class Attribute Summary collapse

Class Method Summary collapse

Class Attribute Details

.db_config ⇒ Object

Class Method Details

.create_clearing_item(order_id, force = false) ⇒ Object

Parameters

.current_week_period_str ⇒ Object

.last_week_period_str ⇒ Object

.load_config ⇒ Object

.on_clearing_item_cash_back(clearing_item_id) ⇒ Object

.on_order_canceled(seller_id, order_id) ⇒ Object

Parameters

.on_order_export_to_erp(order_id) ⇒ Object

.on_order_sale_out(seller_id, order_id) ⇒ Object

Parameters

.on_order_sign_fail(seller_id, order_id) ⇒ Object

Parameters

.on_order_signed(order_id, sign_type) ⇒ Object

Parameters

.on_order_state_change(order_id) ⇒ Object

Parameters

.send_cash_back_notify(order_id, wx_app_id = nil) ⇒ Object

.sq_invite_on_order_delivering(seller_id, order_id) ⇒ Object

.sq_invite_on_order_rejecting(seller_id, order_id) ⇒ Object

.db_config ⇒ `Object`

.create_clearing_item(order_id, force = false) ⇒ `Object`

.current_week_period_str ⇒ `Object`

.last_week_period_str ⇒ `Object`

.load_config ⇒ `Object`

.on_clearing_item_cash_back(clearing_item_id) ⇒ `Object`

.on_order_canceled(seller_id, order_id) ⇒ `Object`

.on_order_export_to_erp(order_id) ⇒ `Object`

.on_order_sale_out(seller_id, order_id) ⇒ `Object`

.on_order_sign_fail(seller_id, order_id) ⇒ `Object`

.on_order_signed(order_id, sign_type) ⇒ `Object`

.on_order_state_change(order_id) ⇒ `Object`

.send_cash_back_notify(order_id, wx_app_id = nil) ⇒ `Object`

.sq_invite_on_order_delivering(seller_id, order_id) ⇒ `Object`

.sq_invite_on_order_rejecting(seller_id, order_id) ⇒ `Object`