liulei/jx-callback
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

修改门店发单和品牌发单是扣费问题

Browse Source
This commit is contained in:
邹宗楠
2023-05-11 10:58:50 +08:00
parent 85b2870a5e
commit 476f8c0943
26 changed files with 417 additions and 273 deletions
Download Patch File Download Diff File Expand all files Collapse all files

88
business/jxcallback/orderman/order.go
View File

@@ -262,9 +262,6 @@ func (c *OrderManager) OnOrderStatusChanged(vendorOrgCode string, orderStatus *m
if err != nil {
globals.SugarLogger.Debug("Get store Detail Err: ", err)
}
//门店发单的订单，取消后要退回配送费
ResetCreateWaybillFee(db, order)
}
}
@@ -453,71 +450,50 @@ func filterOrderInfo(order *model.GoodsOrder) {
order.ConsigneeAddress = strings.ReplaceAll(order.ConsigneeAddress, "·", "")
}
func ResetCreateWaybillFee(db *dao.DaoDB, order *model.GoodsOrder) (err error) {
func ResetCreateWaybillFee(db *dao.DaoDB, order *model.GoodsOrder, bill *model.Waybill) (err error) {
if db == nil {
db = dao.GetDB()
}
store, _ := dao.GetStoreDetail(db, jxutils.GetSaleStoreIDFromOrder(order), order.VendorID, order.VendorOrgCode)
if store != nil && store.CreateDeliveryType == model.YES { // 门店发单（非京西品牌）
// 无运单不参与退款
if order.VendorWaybillID == "" {
return err
}
// 自配送不参与退款
if order.VendorOrderID == order.VendorWaybillID {
return err
}
// 获取运单记录
orderStatusList, err := GetOrderStatusList2(order.VendorOrderID, order.VendorWaybillID, 2, order.WaybillVendorID)
if bill.WaybillVendorID != model.VendorIDMTPS && bill.WaybillVendorID != model.VendorIDDada && bill.WaybillVendorID != model.VendorIDFengNiao && bill.WaybillVendorID != model.VendorIDUUPT {
return nil
}
// 订单被取消了,所有运单应该也被取消了,检查是否退还配送费
// 1.查询订单创建的所有运单,三方配送运单(达达,蜂鸟,uu,美团配送),平台自配送订单不参与
if handlerInfo := partner.GetDeliveryPlatformFromVendorID(bill.WaybillVendorID); handlerInfo != nil {
deductFee, err := handlerInfo.Handler.GetDeliverLiquidatedDamages(bill.VendorOrderID, bill.VendorWaybillID)
if err != nil {
return err
}
isRefund := false // 默认可以退费
for _, v := range orderStatusList {
if order.WaybillVendorID == model.VendorIDMTPS && v.VendorStatus == "30" {
isRefund = true
break
}
if order.WaybillVendorID == model.VendorIDFengNiao && v.VendorStatus == "80" {
isRefund = true
break
}
if order.WaybillVendorID == model.VendorIDDada && v.VendorStatus == "3" {
isRefund = true
break
}
if deductFee == 0 {
return nil
}
if isRefund { // 骑手已经到店了，无法退款
return errors.New("骑手已到店，无法退款")
}
// 更新运单实际扣除费用
bill.ActualFee = deductFee
dao.UpdateEntity(db, bill, "ActualFee")
// 获取品牌的支付记录
orderBill, _ := dao.GetBrandBill(db, store.BrandID, order.VendorOrderID, 0, model.BrandBillFeeTypeDelivery, order.VendorWaybillID)
if len(orderBill) <= 0 {
return errors.New("无记录，不退款")
// 门店账户金额扣除
store, _ := dao.GetStoreDetail(db, jxutils.GetSaleStoreIDFromOrder(order), order.VendorID, order.VendorOrgCode)
// 门店发单,扣除门店余额
if store != nil && store.CreateDeliveryType == model.YES {
partner.CurStoreAcctManager.InsertStoreAcctExpendAndUpdateStoreAcctBalance(jxcontext.AdminCtx, store.ID, int(deductFee), partner.StoreAcctTypeExpendCreateWaybillDeductFee, bill.VendorOrderID, bill.VendorWaybillID, 0)
}
for _, v := range orderBill {
if v.BillType == model.BrandBillTypeIncome { // 已经退款了
return errors.New("无法重复退款")
if store != nil && store.CreateDeliveryType == model.NO {
// 获取运单的支出记录
orderBill, _ := dao.GetBrandBill(db, store.BrandID, order.VendorOrderID, model.BrandBillTypeExpend, model.BrandBillFeeTypeDelivery, order.VendorWaybillID)
if len(orderBill) == 0 {
partner.CurStoreAcctManager.InsertBrandBill(jxcontext.AdminCtx, store.BrandID, int(deductFee), model.BrandBillTypeExpend, model.BrandBillFeeTypeDeductFee, order.VendorOrderID, order.VendorWaybillID)
} else {
// 退回扣除的配送费
partner.CurStoreAcctManager.InsertBrandBill(jxcontext.AdminCtx, store.BrandID, orderBill[0].Price, model.BrandBillTypeIncome, model.BrandBillFeeTypeDeductFee, order.VendorOrderID, order.VendorWaybillID)
// 支出配送费违约金
partner.CurStoreAcctManager.InsertBrandBill(jxcontext.AdminCtx, store.BrandID, int(deductFee), model.BrandBillTypeExpend, model.BrandBillFeeTypeDeductFee, order.VendorOrderID, order.VendorWaybillID)
}
}
// 将支出记录修改为退款记录，支付类型为收入，且类型为三方配送时：退费
newBill := &model.BrandBill{
BrandID: store.BrandID,
Price: orderBill[0].Price,
BillType: model.BrandBillTypeIncome,
FeeType: model.BrandBillFeeTypeDelivery,
VendorOrderID: orderBill[0].VendorOrderID,
OrderID: orderBill[0].OrderID,
}
dao.WrapAddIDCULEntity(newBill, "系统退费")
err = dao.CreateEntity(db, newBill)
}
return err
}
@@ -1342,7 +1318,7 @@ func MergeJdsOrders(ctx *jxcontext.Context, vendorOrderIDs []string) (vendorOrde
for _, order := range orders {
var waybill *model.Waybill
//将订单和运单取消
waybills, err := dao.GetWaybills(db, order.VendorOrderID)
waybills, err := dao.GetWaybills(db, order.VendorOrderID, nil)
if err != nil {
return "", err
}
@@ -1475,7 +1451,7 @@ func TransferJdsOrder(ctx *jxcontext.Context, vendorOrderID string, storeID int)
return "", fmt.Errorf("未查询到该订单商品！订单号：[%v]", vendorOrderID)
}
//将订单和运单取消
waybills, err := dao.GetWaybills(db, vendorOrderID)
waybills, err := dao.GetWaybills(db, vendorOrderID, nil)
if err != nil {
return "", err
}
@@ -1656,7 +1632,7 @@ func SendJdwlForJdsOrder(ctx *jxcontext.Context, vendorOrderID string) (err erro
return fmt.Errorf("订单当前状态不支持创建！")
}
waybill := &model.Waybill{}
waybills, err := dao.GetWaybills(db, vendorOrderID)
waybills, err := dao.GetWaybills(db, vendorOrderID, nil)
if err != nil {
return err
}

37
business/jxcallback/scheduler/basesch/basesch.go
View File

@@ -216,28 +216,31 @@ func (c *BaseScheduler) CreateWaybill(platformVendorID int, order *model.GoodsOr
// }
storeDetail, _ := dao.GetStoreDetail(dao.GetDB(), jxutils.GetSaleStoreIDFromOrder(order), order.VendorID, order.VendorOrgCode)
// 获取门店品牌余额
storeAcct, err := cms.GetStoreAcctBalance(ctx, jxutils.GetSaleStoreIDFromOrder(order)) // 获取门店余额
// 如果门店没钱,查看品牌，查询门店品牌id
result, err := partner.CurStoreAcctManager.GetBrandBalance(storeDetail.BrandID) // 品牌余额
if err != nil {
return nil, err
}
//result, err := partner.CurStoreAcctManager.GetBrandBalance(storeDetail.BrandID) // 品牌余额
//if err != nil {
// return nil, err
//}
var balance int
// 门店发单,如果是京西门店,直接使用京西余额,非京西门店使用门店余额,余额不足使用品牌余额!
if order.CreateDeliveryType == model.YES {
if storeDetail.BrandID == scheduler.JXC4B_SHOP || storeDetail.BrandID == scheduler.JXC4B_RAND_JXGY { // 京西品牌,扣门店
balance = storeAcct.AccountBalance
} else {
if storeAcct.AccountBalance >= model.BrandBalanceLimit {
balance = storeAcct.AccountBalance
} else if storeAcct.AccountBalance < model.BrandBalanceLimit && result >= model.BrandBalanceLimit {
balance = result
} else {
balance = 0
}
storeAcct, err := cms.GetStoreAcctBalance(ctx, jxutils.GetSaleStoreIDFromOrder(order)) // 获取门店余额
if err != nil {
return nil, err
}
balance = storeAcct.AccountBalance
//if storeDetail.BrandID == scheduler.JXC4B_SHOP || storeDetail.BrandID == scheduler.JXC4B_RAND_JXGY { // 京西品牌,扣门店
// balance = storeAcct.AccountBalance
//} else {
// if storeAcct.AccountBalance >= model.BrandBalanceLimit {
// balance = storeAcct.AccountBalance
// } else if storeAcct.AccountBalance < model.BrandBalanceLimit && result >= model.BrandBalanceLimit {
// balance = result
// } else {
// balance = 0
// }
//}
} else {
balance, _ = partner.CurStoreAcctManager.GetBrandBalance(storeDetail.BrandID)
}
@@ -281,7 +284,7 @@ func (c *BaseScheduler) CancelWaybill(bill *model.Waybill, cancelReasonID int, c
return err
}
order, _ := partner.CurOrderManager.LoadOrder(bill.VendorOrderID, bill.OrderVendorID)
return orderman.ResetCreateWaybillFee(nil, order)
return orderman.ResetCreateWaybillFee(nil, order, bill)
}, "CancelWaybill bill:%v", bill); err == nil {
bill.Status = model.WaybillStatusCanceled
bill.DeliveryFlag |= model.WaybillDeliveryFlagMaskActiveCancel

58
business/jxcallback/scheduler/basesch/basesch_ext.go
View File

@@ -228,7 +228,7 @@ func (c *BaseScheduler) AgreeOrRefuseRefund(ctx *jxcontext.Context, afsOrderID s
var (
db = dao.GetDB()
)
waybills, _ := dao.GetWaybills(db, order.VendorOrderID)
waybills, _ := dao.GetWaybills(db, order.VendorOrderID, nil)
//美团的订单如果是同意全部退款，要取消所有三方运单并停止调度
if order.VendorID == model.VendorIDMTWM || order.VendorID == model.VendorIDJX || order.VendorID == model.VendorIDEBAI {
var (
@@ -347,16 +347,23 @@ func (c *BaseScheduler) ConfirmSelfTake(ctx *jxcontext.Context, vendorOrderID st
return err
}
func (c *BaseScheduler) SetOrderWaybillTip(ctx *jxcontext.Context, vendorOrderID string, vendorID int, tipFee int64) (errCode string, err error) {
func (c *BaseScheduler) SetOrderWaybillTip(ctx *jxcontext.Context, vendorOrderID string, vendorID int, tipFee int64, isPay int) (errCode string, err error) {
if order, err := partner.CurOrderManager.LoadOrder(vendorOrderID, vendorID); err == nil {
if errCode, err = c.CheckStoreBalanceWithTip(ctx, order, tipFee); err == nil {
if errCode, err = c.CheckStoreBalanceWithTip(ctx, order, tipFee, isPay); err == nil {
err = c.SetOrderWaybillTipByOrder(ctx, order, tipFee)
}
}
return errCode, err
}
func (c *BaseScheduler) CheckStoreBalanceWithTip(ctx *jxcontext.Context, order *model.GoodsOrder, tipFee int64) (errCode string, err error) {
func (c *BaseScheduler) CheckStoreBalanceWithTip(ctx *jxcontext.Context, order *model.GoodsOrder, tipFee int64, isPay int) (errCode string, err error) {
var (
db = dao.GetDB()
)
roundTipFee := tipFee / 100 * 100
if roundTipFee != tipFee {
return model.ErrCodeOnePayTipFeeMore, fmt.Errorf("小费必须是1元的整数倍")
}
if order.CreateDeliveryType == model.YES {
//加小费只判断余额
storeAcct, err := cms.GetStoreAcctBalance(ctx, jxutils.GetSaleStoreIDFromOrder(order))
@@ -366,10 +373,32 @@ func (c *BaseScheduler) CheckStoreBalanceWithTip(ctx *jxcontext.Context, order *
if tipFee > int64(storeAcct.AccountBalance) {
return model.ErrCodeAccountBalanceNotEnough, fmt.Errorf("门店账户余额不足，不能加小费！")
}
if tipFee >= 1000 {
return model.ErrCodeAccountBalanceNotEnough, fmt.Errorf("小费单次加价金额大于十元")
if tipFee > 1000 {
return model.ErrCodeAccountBalanceNotEnough, fmt.Errorf("小费单次加价金额大于五元")
}
} else {
// 品牌发单
storeDetail, err := dao.GetStoreDetail(db, order.JxStoreID, order.VendorID, order.VendorOrgCode)
if err != nil || storeDetail == nil {
return model.ErrCodeAccountBalanceNotEnough, fmt.Errorf("根据订单获取门店详情错误:%v", err)
}
brandAcct, err := dao.GetBrandBalance(db, storeDetail.BrandID)
if err != nil {
return "", err
}
if tipFee > int64(brandAcct) {
return model.ErrCodeAccountBalanceNotEnough, fmt.Errorf("品牌账户余额不足，不能加小费！")
}
if tipFee > 1000 {
return model.ErrCodeOnePayTipFeeMore, fmt.Errorf("小费单次加价金额大于五元")
}
}
// 是否确认支付
if isPay != model.YES {
return model.ErrCodeIsPaySure, fmt.Errorf("此订单已经支付小费[%d]元,本次增加小费[%d]元,总支出小费[%d]元", order.WaybillTipMoney/100, tipFee/100, order.WaybillTipMoney+tipFee/100)
}
return errCode, err
}
@@ -379,13 +408,6 @@ func isWaybillCanAddTip(waybill *model.Waybill) (isCan bool) {
}
func (c *BaseScheduler) SetOrderWaybillTipByOrder(ctx *jxcontext.Context, order *model.GoodsOrder, tipFee int64) (err error) {
roundTipFee := tipFee / 100 * 100
if roundTipFee != tipFee {
return fmt.Errorf("小费必须是1元的整数倍")
}
if order.WaybillTipMoney >= tipFee {
return fmt.Errorf("当前小费已经是%s元，想要设置%s元", jxutils.IntPrice2StandardString(order.WaybillTipMoney), jxutils.IntPrice2StandardString(tipFee))
}
db := dao.GetDB()
storeDetail, _ := dao.GetStoreDetail(db, jxutils.GetSaleStoreIDFromOrder(order), order.VendorID, "")
flag := false
@@ -396,7 +418,11 @@ func (c *BaseScheduler) SetOrderWaybillTipByOrder(ctx *jxcontext.Context, order
} else {
//加小费成功扣钱
if order.CreateDeliveryType == model.YES {
if err = partner.CurStoreAcctManager.InsertStoreAcctExpendAndUpdateStoreAcctBalance(ctx, jxutils.GetSaleStoreIDFromOrder(order), 100, partner.StoreAcctTypeExpendCreateWaybillTip, order.VendorOrderID, 0); err == nil {
if err = partner.CurStoreAcctManager.InsertStoreAcctExpendAndUpdateStoreAcctBalance(ctx, jxutils.GetSaleStoreIDFromOrder(order), int(tipFee), partner.StoreAcctTypeExpendCreateWaybillTip, order.VendorOrderID, "", 0); err == nil {
flag = true
}
} else if order.CreateDeliveryType == model.NO {
if err = partner.CurStoreAcctManager.InsertBrandBill(ctx, storeDetail.BrandID, int(tipFee), model.BrandBillTypeExpend, model.BrandBillFeeTypeTipFee, order.VendorOrderID, ""); err == nil {
flag = true
}
}
@@ -432,7 +458,9 @@ func (c *BaseScheduler) SetOrderWaybillTipByOrder(ctx *jxcontext.Context, order
if !flag {
//加小费成功扣钱
if order.CreateDeliveryType == model.YES {
partner.CurStoreAcctManager.InsertStoreAcctExpendAndUpdateStoreAcctBalance(ctx, jxutils.GetSaleStoreIDFromOrder(order), 100, partner.StoreAcctTypeExpendCreateWaybillTip, order.VendorOrderID, 0)
partner.CurStoreAcctManager.InsertStoreAcctExpendAndUpdateStoreAcctBalance(ctx, jxutils.GetSaleStoreIDFromOrder(order), int(tipFee), partner.StoreAcctTypeExpendCreateWaybillTip, order.VendorOrderID, "", 0)
} else if order.CreateDeliveryType == model.NO {
partner.CurStoreAcctManager.InsertBrandBill(ctx, storeDetail.BrandID, int(tipFee), model.BrandBillTypeExpend, model.BrandBillFeeTypeTipFee, order.VendorOrderID, "")
}
}
}

30
business/jxcallback/scheduler/defsch/defsch.go
View File

@@ -2,6 +2,7 @@ package defsch
import (
"fmt"
"git.rosy.net.cn/baseapi/platformapi/mtpsapi"
"git.rosy.net.cn/jx-callback/business/jxutils/smsmsg"
"math/rand"
"strings"
@@ -634,13 +635,19 @@ func (s *DefScheduler) OnWaybillStatusChanged(bill *model.Waybill, isPending boo
//if bill.Status == model.WaybillStatusDelivering && order.VendorID == model.VendorIDJX && order.OrderType == model.OrderTypeNormal {
// smsmsg.NotifyJxOrder(order, bill)
//}
//扣除品牌费用
if storeDetail, err2 := dao.GetStoreDetail(dao.GetDB(), jxutils.GetSaleStoreIDFromOrder(order), order.VendorID, ""); err2 == nil {
if storeDetail.CreateDeliveryType == model.YES {
s.updateStoreAccount(order, bill)
}
if !model.IsWaybillPlatformOwn(bill) {
s.updateBrandAccount(storeDetail, bill)
// 当运单时三方配送时,美团状态20
if bill.WaybillVendorID == model.VendorIDDada || bill.WaybillVendorID == model.VendorIDMTPS || bill.WaybillVendorID == model.VendorIDFengNiao || bill.WaybillVendorID == model.VendorIDUUPT {
if (bill.VendorStatus == utils.Int64ToStr(mtpsapi.OrderStatusPickedUp) && bill.OrderVendorID == model.VendorIDMTWM) || bill.Status == model.WaybillStatusCourierArrived {
if storeDetail, err2 := dao.GetStoreDetail(dao.GetDB(), jxutils.GetSaleStoreIDFromOrder(order), order.VendorID, ""); err2 == nil {
if storeDetail.CreateDeliveryType == model.YES {
s.updateStoreAccount(order, bill)
} else {
s.updateBrandAccount(storeDetail, bill)
}
//if !model.IsWaybillPlatformOwn(bill) {
// s.updateBrandAccount(storeDetail, bill)
//}
}
}
}
@@ -763,6 +770,7 @@ func (s *DefScheduler) OnWaybillStatusChanged(bill *model.Waybill, isPending boo
// // s.ProxyCancelWaybill(order, bill, partner.CancelWaybillReasonNotAcceptIntime, partner.CancelWaybillReasonStrNotAcceptIntime)
// globals.SugarLogger.Infof("OnWaybillStatusChanged Delivering order(%d, %s) bill(%d, %s), bill:%v shouldn't get here", order.WaybillVendorID, order.VendorWaybillID, bill.WaybillVendorID, bill.VendorWaybillID, bill)
// }
case model.WaybillStatusDelivered:
s.resetTimer(savedOrderInfo, bill, isPending)
s.removeWaybillFromMap(savedOrderInfo, bill.WaybillVendorID)
@@ -1439,10 +1447,10 @@ func (s *DefScheduler) updateStoreAccount(order *model.GoodsOrder, bill *model.W
var diffFee int64
if lastFee64 > realDesiredFee {
diffFee = lastFee64 - realDesiredFee
partner.CurStoreAcctManager.InsertStoreAcctIncomeAndUpdateStoreAcctBalance(jxcontext.AdminCtx, jxutils.GetSaleStoreIDFromOrder(order), int(diffFee), partner.StoreAcctTypeRealFeeIncome, order.VendorOrderID, expend.ID)
partner.CurStoreAcctManager.InsertStoreAcctIncomeAndUpdateStoreAcctBalance(jxcontext.AdminCtx, jxutils.GetSaleStoreIDFromOrder(order), int(diffFee), partner.StoreAcctTypeRealFeeIncome, order.VendorOrderID, bill.VendorWaybillID, expend.ID)
} else {
diffFee = realDesiredFee - lastFee64
partner.CurStoreAcctManager.InsertStoreAcctIncomeAndUpdateStoreAcctBalance(jxcontext.AdminCtx, jxutils.GetSaleStoreIDFromOrder(order), int(diffFee), partner.StoreAcctTypeRealFeeExpend, order.VendorOrderID, expend.ID)
partner.CurStoreAcctManager.InsertStoreAcctExpendAndUpdateStoreAcctBalance(jxcontext.AdminCtx, jxutils.GetSaleStoreIDFromOrder(order), int(diffFee), partner.StoreAcctTypeRealFeeExpend, order.VendorOrderID, "", expend.ID)
}
}
}
@@ -1460,6 +1468,10 @@ func (s *DefScheduler) updateBrandAccount(store *dao.StoreDetail, bill *model.Wa
}
if sum == 0 {
partner.CurStoreAcctManager.InsertBrandBill(jxcontext.AdminCtx, store.BrandID, int(bill.DesiredFee), model.BrandBillTypeExpend, model.BrandBillFeeTypeDelivery, bill.VendorOrderID, bill.VendorWaybillID)
} else if bill.DesiredFee > int64(sum) {
partner.CurStoreAcctManager.InsertBrandBill(jxcontext.AdminCtx, store.BrandID, int(bill.DesiredFee-int64(sum)), model.BrandBillTypeExpend, model.BrandBillFeeTypeDelivery, bill.VendorOrderID, bill.VendorWaybillID)
} else if bill.DesiredFee < int64(sum) {
partner.CurStoreAcctManager.InsertBrandBill(jxcontext.AdminCtx, store.BrandID, int(int64(sum)-bill.DesiredFee), model.BrandBillTypeIncome, model.BrandBillFeeTypeDelivery, bill.VendorOrderID, bill.VendorWaybillID)
}
}
}

190
business/jxcallback/scheduler/defsch/defsch_ext.go
View File

@@ -177,24 +177,20 @@ func (s *DefScheduler) CreateWaybillOnProviders4SavedOrder(ctx *jxcontext.Contex
// 获取门店品牌余额
storeAcct, err := cms.GetStoreAcctBalance(ctx, jxutils.GetSaleStoreIDFromOrder(order)) // 获取门店余额
// 如果门店没钱,查看品牌，查询门店品牌id
storeList, err := dao.GetStoreList(dao.GetDB(), []int{jxutils.GetSaleStoreIDFromOrder(order)}, nil, nil, nil, nil, "")
if err != nil || len(storeList) != 1 {
return nil, fmt.Errorf("门店id:[%d],所属品牌不唯一,或其他查询错误", order.JxStoreID)
}
result, err := dao.GetBrandBalance(dao.GetDB(), storeList[0].BrandID) // 品牌余额
// 门店详细信息
storeList, err := dao.GetStoreDetail(dao.GetDB(), jxutils.GetSaleStoreIDFromOrder(order), savedOrderInfo.order.VendorID, order.VendorOrgCode)
if err != nil {
return nil, err
}
//门店发单开始扣钱
deliveryFeeMap, _ := s.QueryOrderWaybillFeeInfoEx(ctx, order.VendorOrderID, order.VendorID)
// 不管是门店发单还是品牌发单都要扣钱,门店发单扣门店,品牌发单扣品牌
if order.CreateDeliveryType == model.YES {
deliveryFeeMap, _ := s.QueryOrderWaybillFeeInfoEx(ctx, order.VendorOrderID, order.VendorID)
// 运费相等为0或支出大于收入不做，
isEqual, isZero, _ := partner.CurStoreAcctManager.CheckStoreAcctExpendExist(order.VendorOrderID)
expend, lastFee, _ := partner.CurStoreAcctManager.GetStoreAcctExpendLastCreateWayBillFee(order.VendorOrderID)
// 获取平台配送费
isEqual, isZero, _ := partner.CurStoreAcctManager.CheckStoreAcctExpendExist(order.VendorOrderID) // 当前订单的支出记录
expend, lastFee, _ := partner.CurStoreAcctManager.GetStoreAcctExpendLastCreateWayBillFee(order.VendorOrderID) // 最后一个运单支出记录
// 收最贵的一个订单配送费(配送费发送变化,收取最贵的价格)
if !isZero && !isEqual {
if !isZero && !isEqual { // 满足此条件是,门店发单已经存在此订单的发单记录
var newPrice int64
if len(courierVendorIDs) == 1 {
courierVendorID := courierVendorIDs[0]
@@ -210,51 +206,45 @@ func (s *DefScheduler) CreateWaybillOnProviders4SavedOrder(ctx *jxcontext.Contex
}
newPrice = maxFee
}
// 门店支出运费
if storeList[0].BrandID != scheduler.JXC4B_SHOP && storeList[0].BrandID != scheduler.JXC4B_RAND_JXGY { // 非京西品牌,先扣门店在扣品牌
// 门店支出运费,门店发单
if order.CreateDeliveryType == model.YES {
if storeAcct.AccountBalance > int(newPrice) {
if int(newPrice) > lastFee {
// 门店支出费用
partner.CurStoreAcctManager.InsertStoreAcctExpendAndUpdateStoreAcctBalance(ctx, jxutils.GetSaleStoreIDFromOrder(order), int(model.Waybill{}.DesiredFee), partner.StoreAcctTypeExpendCreateWaybill2ndMore, order.VendorOrderID, expend.ID) //int(newPrice)-lastFee
partner.CurStoreAcctManager.InsertStoreAcctExpendAndUpdateStoreAcctBalance(ctx, jxutils.GetSaleStoreIDFromOrder(order), int(newPrice)-lastFee, partner.StoreAcctTypeExpendCreateWaybill2ndMore, order.VendorOrderID, "", expend.ID) //int(newPrice)-lastFee
}
} else if result > int(newPrice) {
// 品牌支出费用
partner.CurStoreAcctManager.InsertBrandBill(jxcontext.AdminCtx, storeList[0].BrandID, int(model.Waybill{}.DesiredFee), model.BrandBillTypeExpend, model.BrandBillFeeTypeDelivery, order.VendorOrderID, order.VendorWaybillID)
} else {
return nil, fmt.Errorf("门店id:[%d],品牌id:[]%d,门店以及门店所属品牌余额不足,无法发单", order.JxStoreID, storeList[0].BrandID)
}
} else { // 京西品牌
} /*else { // 品牌发单,品牌支出运费
if storeAcct.AccountBalance > int(newPrice) {
if int(newPrice) > lastFee {
// 门店支出费用
partner.CurStoreAcctManager.InsertStoreAcctExpendAndUpdateStoreAcctBalance(ctx, jxutils.GetSaleStoreIDFromOrder(order), int(model.Waybill{}.DesiredFee), partner.StoreAcctTypeExpendCreateWaybill2ndMore, order.VendorOrderID, expend.ID) //int(newPrice)-lastFee
// 品牌支出费用
partner.CurStoreAcctManager.InsertBrandBill(jxcontext.AdminCtx, storeList.BrandID, int(newPrice), model.BrandBillTypeExpend, model.BrandBillFeeTypeDelivery, order.VendorOrderID, order.VendorWaybillID)
}
} else {
return nil, fmt.Errorf("门店id:[%d],品牌id:[]%d,门店以及门店所属品牌余额不足,无法发单", order.JxStoreID, storeList[0].BrandID)
}
}
}*/
} else {
} else { // 新订单的发单记录,门店发单扣门店,品牌发单扣品牌
if len(courierVendorIDs) == 1 {
courierVendorID := courierVendorIDs[0]
if _, ok := deliveryFeeMap[courierVendorID]; ok {
if storeList[0].BrandID != scheduler.JXC4B_SHOP && storeList[0].BrandID != scheduler.JXC4B_RAND_JXGY { // 非京西品牌,先扣门店在扣品牌
if storeAcct.AccountBalance > int(model.Waybill{}.DesiredFee) {
partner.CurStoreAcctManager.InsertStoreAcctExpendAndUpdateStoreAcctBalance(ctx, jxutils.GetSaleStoreIDFromOrder(order), int(model.Waybill{}.DesiredFee), partner.StoreAcctTypeExpendCreateWaybill2ndMore, order.VendorOrderID, expend.ID) //int(newPrice)-lastFee
} else if result > int(model.Waybill{}.DesiredFee) {
// 品牌支出费用
partner.CurStoreAcctManager.InsertBrandBill(jxcontext.AdminCtx, storeList[0].BrandID, int(model.Waybill{}.DesiredFee), model.BrandBillTypeExpend, model.BrandBillFeeTypeDelivery, order.VendorOrderID, order.VendorWaybillID)
} else {
return nil, fmt.Errorf("门店id:[%d],品牌id:[]%d,门店以及门店所属品牌余额不足,无法发单", order.JxStoreID, storeList[0].BrandID)
}
} else { // 京西品牌
if storeAcct.AccountBalance > int(model.Waybill{}.DesiredFee) {
// 门店支出费用
partner.CurStoreAcctManager.InsertStoreAcctExpendAndUpdateStoreAcctBalance(ctx, jxutils.GetSaleStoreIDFromOrder(order), int(model.Waybill{}.DesiredFee), partner.StoreAcctTypeExpendCreateWaybill2ndMore, order.VendorOrderID, expend.ID) //int(newPrice)-lastFee
} else {
return nil, fmt.Errorf("门店id:[%d],品牌id:[]%d,门店以及门店所属品牌余额不足,无法发单", order.JxStoreID, storeList[0].BrandID)
}
}
//if storeList.BrandID != scheduler.JXC4B_SHOP && storeList.BrandID != scheduler.JXC4B_RAND_JXGY { // 非京西品牌,先扣门店在扣品牌
//if storeAcct.AccountBalance > int(model.Waybill{}.DesiredFee) {
if order.CreateDeliveryType == model.YES {
err = partner.CurStoreAcctManager.InsertStoreAcctExpendAndUpdateStoreAcctBalance(ctx, jxutils.GetSaleStoreIDFromOrder(order), int(deliveryFeeMap[courierVendorID].DeliveryFee), partner.StoreAcctTypeExpendCreateWaybillEx, order.VendorOrderID, "", 0) //int(newPrice)-lastFee
globals.SugarLogger.Debugf("InsertStoreAcctExpendAndUpdateStoreAcctBalance 238 err := %v", err)
} /*else {
partner.CurStoreAcctManager.InsertBrandBill(jxcontext.AdminCtx, storeList.BrandID, int(bill.DesiredFee), model.BrandBillTypeExpend, model.BrandBillFeeTypeDelivery, bill.VendorOrderID, bill.VendorWaybillID)
}*/
//} /*else if result > int(model.Waybill{}.DesiredFee) {
// 品牌支出费用
// partner.CurStoreAcctManager.InsertBrandBill(jxcontext.AdminCtx, storeList.BrandID, int(model.Waybill{}.DesiredFee), model.BrandBillTypeExpend, model.BrandBillFeeTypeDelivery, order.VendorOrderID, order.VendorWaybillID)
//}*/
//} else { // 京西品牌
// if storeAcct.AccountBalance > int(model.Waybill{}.DesiredFee) {
// // 门店支出费用
// partner.CurStoreAcctManager.InsertStoreAcctExpendAndUpdateStoreAcctBalance(ctx, jxutils.GetSaleStoreIDFromOrder(order), int(model.Waybill{}.DesiredFee), partner.StoreAcctTypeExpendCreateWaybill2ndMore, order.VendorOrderID, expend.ID) //int(newPrice)-lastFee
// }
//}
}
} else if len(courierVendorIDs) == 0 {
var maxFee int64
@@ -263,12 +253,34 @@ func (s *DefScheduler) CreateWaybillOnProviders4SavedOrder(ctx *jxcontext.Contex
v.DeliveryFee = maxFee
}
}
partner.CurStoreAcctManager.InsertStoreAcctExpendAndUpdateStoreAcctBalance(ctx, jxutils.GetSaleStoreIDFromOrder(order), int(model.Waybill{}.DesiredFee), partner.StoreAcctTypeExpendCreateWaybillEx, order.VendorOrderID, 0) //int(maxFee)
err = partner.CurStoreAcctManager.InsertStoreAcctExpendAndUpdateStoreAcctBalance(ctx, jxutils.GetSaleStoreIDFromOrder(order), int(maxFee), partner.StoreAcctTypeExpendCreateWaybillEx, order.VendorOrderID, "", 0) //int(maxFee)
globals.SugarLogger.Debugf("InsertStoreAcctExpendAndUpdateStoreAcctBalance 260 err := %v", err)
}
}
} else {
// 看看此订单有无发单记录,小费记录
// 品牌发单
if len(courierVendorIDs) == 1 {
courierVendorID := courierVendorIDs[0]
if _, ok := deliveryFeeMap[courierVendorID]; ok {
err = partner.CurStoreAcctManager.InsertBrandBill(jxcontext.AdminCtx, storeList.BrandID, int(deliveryFeeMap[courierVendorID].DeliveryFee), model.BrandBillTypeExpend, model.BrandBillFeeTypeDelivery, order.VendorOrderID, order.VendorWaybillID)
}
} else if len(courierVendorIDs) == 0 {
var maxFee int64
for _, v := range deliveryFeeMap {
if v.DeliveryFee > maxFee {
v.DeliveryFee = maxFee
}
}
err = partner.CurStoreAcctManager.InsertBrandBill(jxcontext.AdminCtx, storeList.BrandID, int(maxFee), model.BrandBillTypeExpend, model.BrandBillFeeTypeDelivery, order.VendorOrderID, order.VendorWaybillID)
globals.SugarLogger.Debugf("InsertStoreAcctExpendAndUpdateStoreAcctBalance 260 err := %v", err)
}
}
return bills, err
}
return bills, err
}
}
if err != nil {
@@ -328,27 +340,54 @@ func (s *DefScheduler) CreateWaybillOnProvidersEx(ctx *jxcontext.Context, vendor
}
func (s *DefScheduler) CheckStoreBalance(ctx *jxcontext.Context, order *model.GoodsOrder, courierVendorIDs []int) (errCode string, err error) {
if order.CreateDeliveryType == model.YES {
var (
db = dao.GetDB()
)
deliveryFeeMap, _ := s.QueryOrderWaybillFeeInfoEx(ctx, order.VendorOrderID, order.VendorID)
if err != nil {
return errCode, fmt.Errorf("获取订单配送费错误[%v]！", err)
}
switch order.CreateDeliveryType {
case model.NO: // 品牌发单
storeDetail, err := dao.GetStoreDetail(db, jxutils.GetSaleStoreIDFromOrder(order), order.VendorID, "")
if err != nil {
return "", err
}
brandAcct, err := dao.GetBrandBalance(db, storeDetail.BrandID)
if err != nil {
return "", err
}
if len(courierVendorIDs) == 1 {
courierVendorID := courierVendorIDs[0]
if _, ok := deliveryFeeMap[courierVendorID]; ok {
if deliveryFeeMap[courierVendorID].DeliveryFee > int64(brandAcct) {
return model.ErrCodeAccountBalanceNotEnough, fmt.Errorf("品牌账户余额小于[%v]元，不能发配送！", jxutils.IntPrice2Standard(deliveryFeeMap[courierVendorID].DeliveryFee))
}
}
} else if len(courierVendorIDs) == 0 {
var maxFee int64
for _, v := range deliveryFeeMap {
if v.DeliveryFee > maxFee {
v.DeliveryFee = maxFee
}
}
if maxFee > int64(brandAcct) {
return model.ErrCodeAccountBalanceNotEnough, fmt.Errorf("品牌账户余额小于[%v]元，不能发配送！", jxutils.IntPrice2Standard(maxFee))
}
}
case model.YES: // 门店发单
//暂时这么认为，len courierVendorIDs 为1表示是老板或者运营从小程序上点的立即发单，因为小程序上是点哪个发哪个
//京西后台则是点一下发3个，len courierVendorIDs 是0
//如果是小程序上点哪个扣哪个平台的钱
//如果是后台，则选最高的那个扣
storeAcct, err := cms.GetStoreAcctBalance(ctx, jxutils.GetSaleStoreIDFromOrder(order)) // 获取门店余额
// 如果门店没钱,查看品牌，查询门店品牌id
storeList, err := dao.GetStoreList(dao.GetDB(), []int{jxutils.GetSaleStoreIDFromOrder(order)}, nil, nil, nil, nil, "")
if err != nil || len(storeList) != 1 {
return "", fmt.Errorf("门店id:[%d],所属品牌不唯一,或其他查询错误", order.JxStoreID)
}
result, err := dao.GetBrandBalance(dao.GetDB(), storeList[0].BrandID) // 品牌余额
if err != nil {
return "", err
}
deliveryFeeMap, _ := s.QueryOrderWaybillFeeInfoEx(ctx, order.VendorOrderID, order.VendorID)
if err != nil {
return errCode, fmt.Errorf("获取账户余额失败！")
}
//1、先判断是不是第一次发：查询库里是否有这个订单的运费支出记录，再查询是否有相同金额并且类型为回退的收入记录（取消运单退回）
//前者有，后者无， 表示已经发过了，暂未取消，若这这次的发单金额小于上次的金额则不进行判断也不多扣钱，若大于则扣除‘这次金额-上次金额’的钱，余额不足问题也根据这个判断
//前者有，后者有，表示发过并且取消过了，是多次发，直接扣
@@ -356,7 +395,7 @@ func (s *DefScheduler) CheckStoreBalance(ctx *jxcontext.Context, order *model.Go
//2、小程序里这次金额用发单平台的金额，后台里这次金额用所有平台最高费用
isEqual, isZero, err := partner.CurStoreAcctManager.CheckStoreAcctExpendExist(order.VendorOrderID)
//表示前者有，后者无
if !isZero && !isEqual {
if !isZero && !isEqual { // 当前订单支出费用大于,退还费用
var newPrice int64
if len(courierVendorIDs) == 1 {
courierVendorID := courierVendorIDs[0]
@@ -375,28 +414,16 @@ func (s *DefScheduler) CheckStoreBalance(ctx *jxcontext.Context, order *model.Go
_, lastFee, _ := partner.CurStoreAcctManager.GetStoreAcctExpendLastCreateWayBillFee(order.VendorOrderID)
// 如果门店属于京西菜市,京西果园则只能扣门店的金额
if int(newPrice) > lastFee {
if storeList[0].BrandID == scheduler.JXC4B_RAND_JXGY || storeList[0].BrandID == scheduler.JXC4B_SHOP { // 订单所属门店属于京西菜市,果园,则不扣品牌只扣门店)(1果园,菜市,7京西超市)
if storeAcct.AccountBalance < int(newPrice)-lastFee {
return model.ErrCodeAccountBalanceNotEnough, fmt.Errorf("门店/品牌账户余额小于[%v]元，不能发配送！", jxutils.IntPrice2Standard(newPrice-int64(lastFee)))
}
} else {
if storeAcct.AccountBalance < int(newPrice)-lastFee && result < int(newPrice)-lastFee {
return model.ErrCodeAccountBalanceNotEnough, fmt.Errorf("门店/品牌账户余额小于[%v]元，不能发配送！", jxutils.IntPrice2Standard(newPrice-int64(lastFee)))
}
if storeAcct.AccountBalance < int(newPrice)-lastFee /*&& result < int(newPrice)-lastFee*/ {
return model.ErrCodeAccountBalanceNotEnough, fmt.Errorf("门店账户余额小于[%v]元，不能发配送！", jxutils.IntPrice2Standard(newPrice-int64(lastFee)))
}
}
} else {
if len(courierVendorIDs) == 1 {
courierVendorID := courierVendorIDs[0]
if _, ok := deliveryFeeMap[courierVendorID]; ok {
if storeList[0].BrandID == scheduler.JXC4B_RAND_JXGY || storeList[0].BrandID == scheduler.JXC4B_SHOP { // 订单所属门店属于京西菜市,果园,则不扣品牌只扣门店)(1果园,菜市,7京西超市)
if deliveryFeeMap[courierVendorID].DeliveryFee > int64(storeAcct.AccountBalance) {
return model.ErrCodeAccountBalanceNotEnough, fmt.Errorf("门店/品牌账户余额小于[%v]元，不能发配送！", jxutils.IntPrice2Standard(partner.MinCreateWaybillBalance))
}
} else {
if deliveryFeeMap[courierVendorID].DeliveryFee > int64(result) && deliveryFeeMap[courierVendorID].DeliveryFee > int64(storeAcct.AccountBalance) {
return model.ErrCodeAccountBalanceNotEnough, fmt.Errorf("门店/品牌 账户余额小于[%v]元，不能发配送！", jxutils.IntPrice2Standard(deliveryFeeMap[courierVendorID].DeliveryFee))
}
if deliveryFeeMap[courierVendorID].DeliveryFee > int64(storeAcct.AccountBalance) {
return model.ErrCodeAccountBalanceNotEnough, fmt.Errorf("门店账户余额小于[%v]元，不能发配送！", jxutils.IntPrice2Standard(deliveryFeeMap[courierVendorID].DeliveryFee))
}
}
} else if len(courierVendorIDs) == 0 {
@@ -406,18 +433,15 @@ func (s *DefScheduler) CheckStoreBalance(ctx *jxcontext.Context, order *model.Go
v.DeliveryFee = maxFee
}
}
if storeList[0].BrandID == scheduler.JXC4B_RAND_JXGY || storeList[0].BrandID == scheduler.JXC4B_SHOP { // 订单所属门店属于京西菜市,果园,则不扣品牌只扣门店)(1果园,菜市,7京西超市)
if maxFee > int64(storeAcct.AccountBalance) {
return model.ErrCodeAccountBalanceNotEnough, fmt.Errorf("门店/品牌账户余额小于[%v]元，不能发配送！", jxutils.IntPrice2Standard(partner.MinCreateWaybillBalance))
}
} else {
if maxFee > int64(result) && maxFee > int64(storeAcct.AccountBalance) {
return model.ErrCodeAccountBalanceNotEnough, fmt.Errorf("门店/品牌 账户余额小于[%v]元，不能发配送！", jxutils.IntPrice2Standard(maxFee))
}
if maxFee > int64(storeAcct.AccountBalance) {
return model.ErrCodeAccountBalanceNotEnough, fmt.Errorf("门店账户余额小于[%v]元，不能发配送！", jxutils.IntPrice2Standard(maxFee))
}
}
}
default:
return "", fmt.Errorf("不存在的订单发单类型,检查配置")
}
return errCode, err
}

1
business/jxcallback/scheduler/scheduler.go
View File

@@ -21,6 +21,7 @@ const (
const (
JXC4B_RAND_JXGY = 1 // 京西菜市和果园品牌id
JXC4B_SHOP = 7 // 京西超市
JXC4B_ZHIGONG = 8 // 京西直供
)
var (